Calendar.h

#pragma once
//-----------------------------------------------------------------------
// <copyright file="Calendar.cs" company="Aspose Pty Ltd">
//   Copyright (c) 2002-2024 Aspose Pty Ltd. All Rights Reserved.
// </copyright>
//-----------------------------------------------------------------------
 
#include <system/string.h>
#include <system/nullable.h>
#include <system/iequatable.h>
#include <system/guid.h>
#include <system/date_time.h>
#include <cstdint>
 
#include "aspose.tasks.cpp/NullableBool.h"
#include "aspose.tasks.cpp/aspose_tasks_api_defs.h"
 
namespace Aspose
{
namespace Tasks
{
class AssignmentBaseline;
class AutoRecalculationState;
class BaselineTimephasedDataMaker;
namespace Calculations
{
class RescheduleIncompleteWorkCalculator;
class ResourceAssignmentCalculator;
class ResourceAssignmentPeakCalculator;
class ResourceAssignmentRateByDateEnumerator;
class ResourceAssignmentVarianceCalculator;
class ResourceAssignmentWorkCalculator;
class ResourceCalculator;
class ResourceOverAllocationCalculator;
class SummaryTaskCalculator;
class TaskByAssignmentCalculator;
class TaskCalculator;
class TaskProgressCalculator;
class TaskSlackCalculator;
class TaskStatusCalculator;
class TaskVarianceCalculator;
class TimephasedDataCalculator;
class TimephasedIterator;
class TimeScaledCalculator;
} // namespace Calculations
class CalendarCollection;
class CalendarDatesCalculator;
class CalendarException;
class CalendarExceptionCollection;
class CalendarExceptionCollectionWithCache;
namespace Connectivity
{
class MpdCalendarMapper;
class MspCalendarMapper;
class MspDbUtils;
class PmCalendarMapper;
class PrimaveraDbReader;
} // namespace Connectivity
class DailyCalendarRepetition;
class DailyWorkRepetition;
class DatesCalculator;
enum class DayType;
class Duration;
class EVCalculator;
namespace Filters
{
class CalendarRootFilter;
} // namespace Filters
class FixedDurationEffortDrivenTaskPlanner;
class FixedDurationTaskPlanner;
template <typename, typename> class IKeyValueCache;
namespace IO
{
namespace Html
{
class HtmlCalendarTableReader;
} // namespace Html
namespace Mpx
{
class MpxReader;
} // namespace Mpx
namespace MSProject
{
class Mpp12CalendarReader;
class Mpp12CalendarWriter;
class MPP12Reader;
class Mpp14CalendarReader;
class Mpp14CalendarWriter;
class MPP14Reader;
class MPP14ResourceWriter;
class Mpp15CalendarReader;
class Mpp15CalendarWriter;
class Mpp9CalendarReader;
class Mpp9CalendarWriter;
class MPP9Reader;
class MppCalendarReader;
class MPPProjectPropsReader;
class MPPProjectPropsWriter;
class MPPReader;
class MPPResourceReader;
class MPPTaskWriter;
class MPPTimephasedDataReader;
class MppTimephasedDataWriter;
class MppWeekDayReader;
} // namespace MSProject
namespace PrimaveraXml
{
class P6XmlUtils;
class PrimaveraCalendarNodeReader;
class PrimaveraReader;
class PrimaveraResourceNodeReader;
} // namespace PrimaveraXml
namespace Pwa
{
namespace InternalApi
{
class InternalApiProjectSerializer;
namespace Mapping
{
class CalendarToRawValuesMapper;
class ProjectCalendarsMapper;
class ProjectRootMapper;
} // namespace Mapping
} // namespace InternalApi
} // namespace Pwa
namespace Xer
{
class XerAssignmentReader;
class XerCalendarReader;
class XerPrimaveraReader;
class XerProjectNormalizer;
} // namespace Xer
namespace Xml
{
class CalendarFactory;
class CalendarNodeReader;
class CalendarNodeWriter;
class ResourceNodeReader;
class TaskNodeReader;
class TimephasedDataNodeReader;
class WeekDayNodeReader;
class XmlReader;
class XmlWriter;
} // namespace Xml
} // namespace IO
class IReadOnlyWorkingTimeCollection;
namespace Leveling
{
class LevelingAlgorithm;
} // namespace Leveling
class ManualState;
class MonthlyRepetitionBase;
class NullableBool;
class PercentCompleteCalculator;
class ProjDateDiff;
class ProjDateSub;
class Project;
class ProjectIntegrityValidator;
class ProjectState;
class ProjectWorkUpdater;
namespace Recalculation
{
class TaskSplitCalculator;
} // namespace Recalculation
namespace Recurring
{
namespace Calculators
{
class CalendarDayRecurrenceDateCalculator;
class DefaultRecurrenceDateCalculator;
class RecurrenceDateCalculatorBase;
} // namespace Calculators
} // namespace Recurring
class Resource;
class ResourceAssignment;
namespace Saving
{
class HtmlCalendarTable;
class MpxWriter;
class PrimaveraCalendarNodeWriter;
class XerCalendarTable;
} // namespace Saving
namespace Scheduling
{
class ConstraintSolver;
class FromStartScheduler;
class TopsortCriticalPath;
} // namespace Scheduling
class SplitPart;
class SplitsCalculator;
class Task;
class TaskBaseline;
class TaskPlanner;
class TaskPlannerAssignmentManager;
class TaskWarningCalculator;
namespace Timephased
{
class TimephasedDataByScaledEnumerator;
class TimeScaledWorkContourBuilder;
} // namespace Timephased
class TimephasedDataCalculationUtil;
class TimephasedDataMaker;
class TimephasedWorkCostSelector;
class TimeScaledExceptions;
class TimeScaledParentWorkUnit;
namespace Util
{
class CalendarHelper;
class PrimaveraSummaryTasksCalculator;
class PrimaveraTasksProcessor;
} // namespace Util
namespace Validators
{
class RecurringTaskParametersValidator;
} // namespace Validators
class WeekDay;
class WeekDayCollection;
class WeeklyRepetitionBase;
class WorkingTimeCollection;
class WorkUnit;
class WorkWeekCollection;
class YearlyRepetitionBase;
} // namespace Tasks
} // namespace Aspose
namespace System
{
class TimeSpan;
} // namespace System
 
namespace Aspose {
 
namespace Tasks {
 
/// <summary>
/// Represents a calendar used in a project.
/// </summary>
/// <example>
/// How to create simple calendar from scratch.
/// <code>
/// [C#]
/// // create empty calendar
/// Calendar calendar = new Calendar("New calendar");
/// // adds default working days (8 working hours from 9:00 to 17:00)
/// calendar.Days.Add(WeekDay.CreateDefaultWorkingDay(DayType.Monday));
/// calendar.Days.Add(WeekDay.CreateDefaultWorkingDay(DayType.Tuesday));
/// calendar.Days.Add(WeekDay.CreateDefaultWorkingDay(DayType.Wednesday));
/// // create new new working day
/// WeekDay myWeekDay = new WeekDay(DayType.Thursday);
/// // Sets working time. Only time part of DateTime is important
///     WorkingTime wt1 = new WorkingTime();
///     wt1.FromTime = new DateTime(1, 1, 1, 6, 0, 0, 0);
///     wt1.ToTime = new DateTime(1, 1, 1, 12, 0, 0, 0);
///     WorkingTime wt2 = new WorkingTime();
///     wt2.FromTime = new DateTime(1, 1, 1, 14, 0, 0, 0);
///     wt2.ToTime = new DateTime(1, 1, 1, 18, 0, 0, 0);
///     myWeekDay.WorkingTimes.Add(wt1);
///     myWeekDay.WorkingTimes.Add(wt2);
///     myWeekDay.DayWorking = true;
/// calendar.Days.Add(myWeekDay);
/// calendar.Days.Add(WeekDay.CreateDefaultWorkingDay(DayType.Friday));
/// // adds weekend
/// calendar.Days.Add(new WeekDay(DayType.Saturday));
/// calendar.Days.Add(new WeekDay(DayType.Sunday));
/// </code>
/// <code>
/// [VB]
/// ' create empty calendar
/// Dim calendar As Calendar =  New Calendar("New calendar")
/// ' adds default working days (8 working hours from 9:00 to 17:00)
/// calendar.Days.Add(WeekDay.CreateDefaultWorkingDay(DayType.Monday))
/// calendar.Days.Add(WeekDay.CreateDefaultWorkingDay(DayType.Tuesday))
/// calendar.Days.Add(WeekDay.CreateDefaultWorkingDay(DayType.Wednesday))
/// ' create new new working day
/// Dim myWeekDay As WeekDay =  New WeekDay(DayType.Thursday)
/// ' Sets working time. Only time part of DateTime is important
///     Dim wt1 As WorkingTime =  New WorkingTime()
///     wt1.FromTime = New DateTime(1, 1, 1, 6, 0, 0, 0)
///     wt1.ToTime = New DateTime(1, 1, 1, 12, 0, 0, 0)
///     Dim wt2 As WorkingTime =  New WorkingTime()
///     wt2.FromTime = New DateTime(1, 1, 1, 14, 0, 0, 0)
///     wt2.ToTime = New DateTime(1, 1, 1, 18, 0, 0, 0)
///     myWeekDay.WorkingTimes.Add(wt1)
///     myWeekDay.WorkingTimes.Add(wt2)
///     myWeekDay.DayWorking = True
/// calendar.Days.Add(myWeekDay)
/// calendar.Days.Add(WeekDay.CreateDefaultWorkingDay(DayType.Friday))
/// ' adds weekend
/// calendar.Days.Add(New WeekDay(DayType.Saturday))
/// calendar.Days.Add(New WeekDay(DayType.Sunday))
/// </code>
/// </example>
/// <remarks>
/// Calendars are used to define standard working and non-working times.
/// Projects must have one base calendar. Tasks and resources can have
/// their own non-base calendars that are based on a base calendar.
/// </remarks>
class ASPOSE_TASKS_SHARED_CLASS Calendar : public System::Object
{
    typedef Calendar ThisType;
    typedef System::Object BaseType;
    
    typedef ::System::BaseTypesInfo<BaseType> ThisTypeBaseTypesInfo;
    ASPOSE_TASKS_SHARED_RTTI_INFO_DECL();
    
protected:
 
    class CalendarCacheKey;
    
private:
    friend class Aspose::Tasks::AssignmentBaseline;
    friend class Aspose::Tasks::Calculations::RescheduleIncompleteWorkCalculator;
    friend class Aspose::Tasks::Calculations::TimephasedIterator;
    friend class Aspose::Tasks::Calculations::ResourceOverAllocationCalculator;
    friend class Aspose::Tasks::Calculations::TimeScaledCalculator;
    friend class Aspose::Tasks::Calculations::ResourceAssignmentRateByDateEnumerator;
    friend class Aspose::Tasks::Calculations::ResourceAssignmentCalculator;
    friend class Aspose::Tasks::Calculations::ResourceAssignmentPeakCalculator;
    friend class Aspose::Tasks::Calculations::ResourceAssignmentWorkCalculator;
    friend class Aspose::Tasks::Calculations::ResourceCalculator;
    friend class Aspose::Tasks::Calculations::SummaryTaskCalculator;
    friend class Aspose::Tasks::Calculations::TaskByAssignmentCalculator;
    friend class Aspose::Tasks::Calculations::TaskCalculator;
    friend class Aspose::Tasks::Calculations::TaskProgressCalculator;
    friend class Aspose::Tasks::Calculations::ResourceAssignmentVarianceCalculator;
    friend class Aspose::Tasks::Calculations::TaskSlackCalculator;
    friend class Aspose::Tasks::Calculations::TaskVarianceCalculator;
    friend class Aspose::Tasks::Calculations::TaskStatusCalculator;
    friend class Aspose::Tasks::Calculations::TimephasedDataCalculator;
    friend class Aspose::Tasks::Calculations::TimephasedDataCalculator;
    friend class Aspose::Tasks::CalendarCollection;
    friend class Aspose::Tasks::IO::PrimaveraXml::P6XmlUtils;
    friend class Aspose::Tasks::IO::PrimaveraXml::PrimaveraCalendarNodeReader;
    friend class Aspose::Tasks::IO::PrimaveraXml::PrimaveraReader;
    friend class Aspose::Tasks::IO::PrimaveraXml::PrimaveraResourceNodeReader;
    friend class Aspose::Tasks::Leveling::LevelingAlgorithm;
    friend class Aspose::Tasks::Project;
    friend class Aspose::Tasks::ResourceAssignment;
    friend class Aspose::Tasks::Task;
    friend class Aspose::Tasks::BaselineTimephasedDataMaker;
    friend class Aspose::Tasks::Timephased::TimeScaledWorkContourBuilder;
    friend class Aspose::Tasks::Timephased::TimephasedDataByScaledEnumerator;
    friend class Aspose::Tasks::TimephasedDataCalculationUtil;
    friend class Aspose::Tasks::TimeScaledParentWorkUnit;
    friend class Aspose::Tasks::Util::PrimaveraSummaryTasksCalculator;
    friend class Aspose::Tasks::Filters::CalendarRootFilter;
    friend class Aspose::Tasks::IO::Pwa::InternalApi::Mapping::CalendarToRawValuesMapper;
    friend class Aspose::Tasks::IO::Pwa::InternalApi::InternalApiProjectSerializer;
    friend class Aspose::Tasks::IO::Pwa::InternalApi::Mapping::ProjectRootMapper;
    friend class Aspose::Tasks::IO::Xml::CalendarFactory;
    friend class Aspose::Tasks::EVCalculator;
    friend class Aspose::Tasks::ProjDateDiff;
    friend class Aspose::Tasks::ProjDateSub;
    friend class Aspose::Tasks::Connectivity::MpdCalendarMapper;
    friend class Aspose::Tasks::Connectivity::MspCalendarMapper;
    friend class Aspose::Tasks::Connectivity::MspDbUtils;
    friend class Aspose::Tasks::Connectivity::PmCalendarMapper;
    friend class Aspose::Tasks::Connectivity::PrimaveraDbReader;
    friend class Aspose::Tasks::IO::Html::HtmlCalendarTableReader;
    friend class Aspose::Tasks::IO::MSProject::Mpp12CalendarReader;
    friend class Aspose::Tasks::IO::MSProject::MppCalendarReader;
    friend class Aspose::Tasks::IO::MSProject::MPP12Reader;
    friend class Aspose::Tasks::IO::MSProject::MPPReader;
    friend class Aspose::Tasks::IO::MSProject::MPPResourceReader;
    friend class Aspose::Tasks::IO::MSProject::MppWeekDayReader;
    friend class Aspose::Tasks::IO::MSProject::Mpp14CalendarReader;
    friend class Aspose::Tasks::IO::MSProject::MPP14Reader;
    friend class Aspose::Tasks::IO::MSProject::Mpp15CalendarReader;
    friend class Aspose::Tasks::IO::MSProject::Mpp15CalendarWriter;
    friend class Aspose::Tasks::IO::MSProject::Mpp14CalendarWriter;
    friend class Aspose::Tasks::IO::MSProject::MPP14ResourceWriter;
    friend class Aspose::Tasks::IO::MSProject::Mpp9CalendarReader;
    friend class Aspose::Tasks::IO::MSProject::MPP9Reader;
    friend class Aspose::Tasks::IO::MSProject::MPPProjectPropsReader;
    friend class Aspose::Tasks::IO::MSProject::MPPTimephasedDataReader;
    friend class Aspose::Tasks::IO::MSProject::Mpp12CalendarWriter;
    friend class Aspose::Tasks::IO::MSProject::MPPTaskWriter;
    friend class Aspose::Tasks::IO::MSProject::Mpp9CalendarWriter;
    friend class Aspose::Tasks::IO::MSProject::MPPProjectPropsWriter;
    friend class Aspose::Tasks::IO::MSProject::MppTimephasedDataWriter;
    friend class Aspose::Tasks::IO::Mpx::MpxReader;
    friend class Aspose::Tasks::IO::Xer::XerPrimaveraReader;
    friend class Aspose::Tasks::IO::Xer::XerAssignmentReader;
    friend class Aspose::Tasks::IO::Xer::XerCalendarReader;
    friend class Aspose::Tasks::IO::Xer::XerProjectNormalizer;
    friend class Aspose::Tasks::IO::Pwa::InternalApi::Mapping::ProjectCalendarsMapper;
    friend class Aspose::Tasks::IO::Xml::CalendarNodeReader;
    friend class Aspose::Tasks::IO::Xml::CalendarNodeWriter;
    friend class Aspose::Tasks::IO::Xml::ResourceNodeReader;
    friend class Aspose::Tasks::IO::Xml::TaskNodeReader;
    friend class Aspose::Tasks::IO::Xml::TimephasedDataNodeReader;
    friend class Aspose::Tasks::IO::Xml::WeekDayNodeReader;
    friend class Aspose::Tasks::IO::Xml::XmlReader;
    friend class Aspose::Tasks::IO::Xml::XmlWriter;
    friend class Aspose::Tasks::ProjectIntegrityValidator;
    friend class Aspose::Tasks::AutoRecalculationState;
    friend class Aspose::Tasks::ProjectState;
    friend class Aspose::Tasks::CalendarDatesCalculator;
    friend class Aspose::Tasks::DatesCalculator;
    friend class Aspose::Tasks::TaskPlannerAssignmentManager;
    friend class Aspose::Tasks::FixedDurationEffortDrivenTaskPlanner;
    friend class Aspose::Tasks::TaskPlanner;
    friend class Aspose::Tasks::FixedDurationTaskPlanner;
    friend class Aspose::Tasks::ManualState;
    friend class Aspose::Tasks::PercentCompleteCalculator;
    friend class Aspose::Tasks::ProjectWorkUpdater;
    friend class Aspose::Tasks::SplitsCalculator;
    friend class Aspose::Tasks::Recalculation::TaskSplitCalculator;
    friend class Aspose::Tasks::TaskWarningCalculator;
    friend class Aspose::Tasks::Recurring::Calculators::CalendarDayRecurrenceDateCalculator;
    friend class Aspose::Tasks::Recurring::Calculators::RecurrenceDateCalculatorBase;
    friend class Aspose::Tasks::DailyCalendarRepetition;
    friend class Aspose::Tasks::DailyWorkRepetition;
    friend class Aspose::Tasks::Recurring::Calculators::DefaultRecurrenceDateCalculator;
    friend class Aspose::Tasks::MonthlyRepetitionBase;
    friend class Aspose::Tasks::WeeklyRepetitionBase;
    friend class Aspose::Tasks::YearlyRepetitionBase;
    friend class Aspose::Tasks::Saving::HtmlCalendarTable;
    friend class Aspose::Tasks::Saving::MpxWriter;
    friend class Aspose::Tasks::Saving::XerCalendarTable;
    friend class Aspose::Tasks::Saving::PrimaveraCalendarNodeWriter;
    friend class Aspose::Tasks::Scheduling::ConstraintSolver;
    friend class Aspose::Tasks::Scheduling::TopsortCriticalPath;
    friend class Aspose::Tasks::Scheduling::FromStartScheduler;
    friend class Aspose::Tasks::SplitPart;
    friend class Aspose::Tasks::TaskBaseline;
    friend class Aspose::Tasks::TimephasedDataMaker;
    friend class Aspose::Tasks::TimephasedWorkCostSelector;
    friend class Aspose::Tasks::Util::CalendarHelper;
    friend class Aspose::Tasks::Util::PrimaveraTasksProcessor;
    friend class Aspose::Tasks::Validators::RecurringTaskParametersValidator;
    friend ASPOSE_TASKS_SHARED_API bool operator ==(Calendar::CalendarCacheKey left, Calendar::CalendarCacheKey right);
    friend ASPOSE_TASKS_SHARED_API bool operator !=(Calendar::CalendarCacheKey left, Calendar::CalendarCacheKey right);
    
protected:
 
    class ASPOSE_TASKS_SHARED_CLASS CalendarCacheKey : public System::IEquatable<Aspose::Tasks::Calendar::CalendarCacheKey>, public System::Details::BoxableObjectBase
    {
        typedef CalendarCacheKey ThisType;
        typedef System::IEquatable<Aspose::Tasks::Calendar::CalendarCacheKey> BaseType;
        
        typedef ::System::BaseTypesInfo<BaseType> ThisTypeBaseTypesInfo;
        ASPOSE_TASKS_SHARED_RTTI_INFO_DECL();
        
        friend ASPOSE_TASKS_SHARED_API bool operator ==(Calendar::CalendarCacheKey left, Calendar::CalendarCacheKey right);
        friend ASPOSE_TASKS_SHARED_API bool operator !=(Calendar::CalendarCacheKey left, Calendar::CalendarCacheKey right);
        
    public:
    
        ASPOSE_TASKS_SHARED_API CalendarCacheKey(int32_t calUid, System::DateTime start, System::DateTime finish, double units);
        
        /// <inheritdoc ></inheritdoc>
        ASPOSE_TASKS_SHARED_API bool Equals(Calendar::CalendarCacheKey other) override;
        /// <inheritdoc ></inheritdoc>
        ASPOSE_TASKS_SHARED_API bool Equals(System::SharedPtr<System::Object> obj) override;
        /// <inheritdoc ></inheritdoc>
        ASPOSE_TASKS_SHARED_API int32_t GetHashCode() const override;
        
        ASPOSE_TASKS_SHARED_API CalendarCacheKey();
        
    protected:
    
        #ifdef ASPOSE_GET_SHARED_MEMBERS
        ASPOSE_TASKS_SHARED_API void GetSharedMembers(System::Object::shared_members_type& result) const override;
        #endif
        
        
    private:
    
        double units;
        int32_t calUid;
        System::DateTime start;
        System::DateTime finish;
        int32_t cachedHashCode;
        
    };
    
    
public:
 
    /// <summary>
    /// Gets the name of the calendar.
    /// </summary>
    ASPOSE_TASKS_SHARED_API System::String get_Name() const;
    /// <summary>
    /// Sets the name of the calendar.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_Name(const System::String& value);
    /// <summary>
    /// Gets the unique identifier of the calendar.
    /// </summary>
    ASPOSE_TASKS_SHARED_API int32_t get_Uid() const;
    /// <summary>
    /// Sets the unique identifier of the calendar.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_Uid(int32_t value);
    /// <summary>
    /// Gets WeekDaysCollection for this calendar.
    /// The collection of weekdays that defines the calendar.
    /// </summary>
    ASPOSE_TASKS_SHARED_API const System::SharedPtr<WeekDayCollection>& get_WeekDays() const;
    /// <summary>
    /// Gets CalendarExceptionCollection object.
    /// The collection of exceptions that is associated with the calendar.
    /// </summary>
    ASPOSE_TASKS_SHARED_API System::SharedPtr<CalendarExceptionCollection> get_Exceptions() const;
    /// <summary>
    /// Gets WorkWeekCollections object.
    /// The collection of work weeks that is associated with the calendar.
    /// </summary>
    ASPOSE_TASKS_SHARED_API const System::SharedPtr<WorkWeekCollection>& get_WorkWeeks() const;
    /// <summary>
    /// Gets a value indicating whether the calendar is a base calendar.
    /// </summary>
    ASPOSE_TASKS_SHARED_API bool get_IsBaseCalendar();
    /// <summary>
    /// Gets the base calendar on which this calendar depends.
    /// Only applicable if the calendar is not a base calendar.
    /// </summary>
    ASPOSE_TASKS_SHARED_API System::SharedPtr<Calendar> get_BaseCalendar() const;
    /// <summary>
    /// Sets the base calendar on which this calendar depends.
    /// Only applicable if the calendar is not a base calendar.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_BaseCalendar(const System::SharedPtr<Calendar>& value);
    /// <summary>
    /// Gets a value indicating whether the calendar is a baseline calendar.
    /// </summary>
    ASPOSE_TASKS_SHARED_API bool get_IsBaselineCalendar();
    /// <summary>
    /// Sets a value indicating whether the calendar is a baseline calendar.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_IsBaselineCalendar(bool value);
    /// <summary>
    /// Gets calendar's Guid.
    /// </summary>
    ASPOSE_TASKS_SHARED_API System::String get_Guid() const;
    
    /// <summary>
    /// Creates default standard calendar.
    /// </summary>
    /// <param name="calendar">Calendar to make standard calendar from.</param>
    /// <returns>Calendar with 5 working days (Monday-Friday) with working times 8-12 and 13-17.</returns>
    static ASPOSE_TASKS_SHARED_API System::SharedPtr<Calendar> MakeStandardCalendar(const System::SharedPtr<Calendar>& calendar);
    /// <summary>
    /// Makes a given Calendar to be a 24Hour Calendar.
    /// 24Hours Calendar is a Calendar in which every day of week is working with Round-the-clock working hours.
    /// </summary>
    /// <param name="calendar">Calendar to make 24 Hours Calendar from.</param>
    /// <returns>24Hour Calendar.</returns>
    static ASPOSE_TASKS_SHARED_API System::SharedPtr<Calendar> Make24HourCalendar(const System::SharedPtr<Calendar>& calendar);
    /// <summary>
    /// Makes a given Calendar as Night Shift Calendar.
    /// </summary>
    /// <param name="calendar">Calendar to make Night Shift Calendar.</param>
    /// <returns>Night Shift Calendar.</returns>
    static ASPOSE_TASKS_SHARED_API System::SharedPtr<Calendar> MakeNightShiftCalendar(const System::SharedPtr<Calendar>& calendar);
    /// <summary>
    /// Returns a value indicating whether this instance is equal to a specified object.
    /// </summary>
    /// <param name="obj">The object to compare with this instance.</param>
    /// <returns><b>True</b> if o is a Calendar that has the same Uid value as this instance; otherwise, <b>false</b>.</returns>
    ASPOSE_TASKS_SHARED_API bool Equals(System::SharedPtr<System::Object> obj) override;
    /// <summary>
    /// Returns a hash code for the instance of the class.
    /// </summary>
    /// <returns>a hash code for this object.</returns>
    ASPOSE_TASKS_SHARED_API int32_t GetHashCode() const override;
    /// <summary>
    /// Removes calendar from project.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void Delete();
    /// <summary>
    /// Returns StartDate based on specified FinishDate and Duration.
    /// </summary>
    /// <param name="finish">The specified finish date.</param>
    /// <param name="duration">The specified work duration.</param>
    /// <returns>Calculated StartDate.</returns>
    ASPOSE_TASKS_SHARED_API System::DateTime GetStartDateFromFinishAndDuration(System::DateTime finish, Duration duration);
    /// <summary>
    /// Returns StartDate based on specified FinishDate and Duration.
    /// </summary>
    /// <param name="finish">The specified finish date.</param>
    /// <param name="duration">The specified work duration.</param>
    /// <returns>Calculated StartDate.</returns>
    ASPOSE_TASKS_SHARED_API System::DateTime GetStartDateFromFinishAndDuration(System::DateTime finish, System::TimeSpan duration);
    /// <summary>
    /// Determines whether the day is working day.
    /// </summary>
    /// <param name="dt">The date to check day is working for.</param>
    /// <returns>True if the day is working day.</returns>
    ASPOSE_TASKS_SHARED_API bool IsDayWorking(System::DateTime dt);
    /// <summary>
    /// Return working hours for the specified dates.
    /// </summary>
    /// <param name="start">Start date.</param>
    /// <param name="finish">Finish date.</param>
    /// <returns>Working hours.</returns>
    ASPOSE_TASKS_SHARED_API System::SharedPtr<WorkUnit> GetWorkingHours(System::DateTime start, System::DateTime finish);
    /// <summary>
    /// Calculates the date when the specified amount of work time will pass according to the calendar.
    /// </summary>
    /// <param name="start">Start date.</param>
    /// <param name="work">Work duration.</param>
    /// <returns>Finish date.</returns>
    ASPOSE_TASKS_SHARED_API System::DateTime GetFinishDateByStartAndWork(System::DateTime start, Duration work);
    /// <summary>
    /// Calculates the date when the specified amount of work time will pass according to the calendar.
    /// </summary>
    /// <param name="start">Start date.</param>
    /// <param name="work">Work duration.</param>
    /// <returns>Finish date.</returns>
    ASPOSE_TASKS_SHARED_API System::DateTime GetFinishDateByStartAndWork(System::DateTime start, System::TimeSpan work);
    /// <summary>
    /// Calculates the task finish date and time from its start date, split parts and the duration.
    /// </summary>
    /// <param name="task">The task to get finish date for.</param>
    /// <param name="duration">The task duration to split on.</param>
    /// <returns>Task's finish date.</returns>
    /// <remarks>Returns DateTime.MinValue if task is summary, null or its start date is not set.</remarks>
    ASPOSE_TASKS_SHARED_API System::DateTime GetTaskFinishDateFromDuration(const System::SharedPtr<Task>& task, System::TimeSpan duration);
    /// <summary>
    /// Returns amount of working hours at the date.
    /// </summary>
    /// <param name="dt">The date to get working hours for.</param>
    /// <returns>Working hours.</returns>
    ASPOSE_TASKS_SHARED_API System::TimeSpan GetWorkingHours(System::DateTime dt);
    /// <summary>
    /// Returns <see cref="WorkingTimeCollection"></see> of working times for the specified date.
    /// </summary>
    /// <param name="dt">The date to get working times for.</param>
    /// <returns>List of <see cref="WorkingTime"></see>.</returns>
    ASPOSE_TASKS_SHARED_API System::SharedPtr<WorkingTimeCollection> GetWorkingTimes(System::DateTime dt);
    /// <summary>
    /// Calculates previous working date end from the specified date.
    /// </summary>
    /// <param name="date">the specified instance of <see cref="DateTime"></see> struct.</param>
    /// <returns>Previous working day start <see cref="System::DateTime"></see></returns>
    ASPOSE_TASKS_SHARED_API System::DateTime GetPreviousWorkingDayEnd(System::DateTime date);
    /// <summary>
    /// Calculates next working day start from the date.
    /// </summary>
    /// <param name="date">The date to get next working day start for.</param>
    /// <returns>Next working day start <see cref="System::DateTime"></see>.</returns>
    ASPOSE_TASKS_SHARED_API System::DateTime GetNextWorkingDayStart(System::DateTime date);
    
protected:
 
    /// <summary>
    /// Gets WeekDaysCollection for this calendar.
    /// The collection of weekdays that defines the calendar.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_WeekDays(const System::SharedPtr<WeekDayCollection>& value);
    /// <summary>
    /// Gets calendar's Guid.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_Guid(const System::String& value);
    ASPOSE_TASKS_SHARED_API const System::SharedPtr<Project>& get_ParentProject() const;
    ASPOSE_TASKS_SHARED_API void set_ParentProject(const System::SharedPtr<Project>& value);
    ASPOSE_TASKS_SHARED_API NullableBool get_NullableIsBaselineCalendar() const;
    ASPOSE_TASKS_SHARED_API void set_NullableIsBaselineCalendar(NullableBool value);
    ASPOSE_TASKS_SHARED_API int32_t get_ResourceUid() const;
    ASPOSE_TASKS_SHARED_API void set_ResourceUid(int32_t value);
    ASPOSE_TASKS_SHARED_API bool get_IsNull() const;
    ASPOSE_TASKS_SHARED_API void set_IsNull(bool value);
    ASPOSE_TASKS_SHARED_API bool get_IsZeroResourceCalendar();
    ASPOSE_TASKS_SHARED_API System::Guid get_UnknownGuid() const;
    ASPOSE_TASKS_SHARED_API void set_UnknownGuid(System::Guid value);
    ASPOSE_TASKS_SHARED_API System::SharedPtr<Aspose::Tasks::Resource> get_Resource() const;
    ASPOSE_TASKS_SHARED_API void set_Resource(const System::SharedPtr<Aspose::Tasks::Resource>& value);
    ASPOSE_TASKS_SHARED_API bool get_Is24HourCalendar();
    ASPOSE_TASKS_SHARED_API int32_t get_NonWorkingDayCount();
    ASPOSE_TASKS_SHARED_API int32_t get_WorkingDayCount();
    ASPOSE_TASKS_SHARED_API bool get_IsCacheEnabled();
    ASPOSE_TASKS_SHARED_API void set_IsCacheEnabled(bool value);
    
    /// <summary>
    /// Initializes a new instance of the <see cref="Calendar"></see> class.
    /// </summary>
    ASPOSE_TASKS_SHARED_API Calendar();
    
    ASPOSE_TASKS_SHARED_API MEMBER_FUNCTION_MAKE_OBJECT_DECLARATION(Calendar, CODEPORTING_ARGS());
    
    /// <summary>
    /// Initializes a new instance of the <see cref="Calendar"></see> class and sets Id value.
    /// </summary>
    /// <param name="uid">Unique identifier.</param>
    ASPOSE_TASKS_SHARED_API Calendar(int32_t uid);
    
    ASPOSE_TASKS_SHARED_API MEMBER_FUNCTION_MAKE_OBJECT_DECLARATION(Calendar, CODEPORTING_ARGS(int32_t uid));
    ASPOSE_TASKS_SHARED_API System::TimeSpan GetWorkingHoursTimeSpan(System::DateTime start, System::DateTime finish);
    ASPOSE_TASKS_SHARED_API bool IsDayOff(System::DateTime date);
    ASPOSE_TASKS_SHARED_API System::DateTime GetFinishDateByStartAndDuration(System::DateTime start, Duration duration, bool isLast, bool daysOff);
    ASPOSE_TASKS_SHARED_API System::DateTime GetFinishDateByStartAndDuration(System::DateTime start, System::TimeSpan duration, bool isLast, bool daysOff);
    ASPOSE_TASKS_SHARED_API System::DateTime GetTaskFinishDateFromDuration(const System::SharedPtr<Task>& task, Duration duration);
    ASPOSE_TASKS_SHARED_API System::DateTime GetFinishDateFromStartAndDuration(const System::SharedPtr<Task>& task, System::DateTime start, Duration duration);
    ASPOSE_TASKS_SHARED_API System::DateTime GetStartDateFromFinishAndDuration(const System::SharedPtr<Task>& task, System::DateTime finishDate, Duration duration);
    /// <summary>
    /// Calculates task finish date, splits included.
    /// </summary>
    /// <param name="task">Task to calculate finish for.</param>
    /// <param name="start">Start date to calculate finish from.</param>
    /// <param name="duration">Duration</param>
    /// <returns>Calculated task finish date.</returns>
    ASPOSE_TASKS_SHARED_API System::DateTime GetFinishDateFromStartAndDuration(const System::SharedPtr<Task>& task, System::DateTime start, System::TimeSpan duration);
    /// <summary>
    /// Calculates task start date, splits included.
    /// </summary>
    /// <param name="task">Task to calculate start date for.</param>
    /// <param name="finishDate">Finish date to calculate start from.</param>
    /// <param name="duration">Duration</param>
    /// <returns>Calculated task start date.</returns>
    ASPOSE_TASKS_SHARED_API System::DateTime GetStartDateFromFinishAndDuration(const System::SharedPtr<Task>& task, System::DateTime finishDate, System::TimeSpan duration);
    ASPOSE_TASKS_SHARED_API System::TimeSpan GetWork(System::DateTime start, System::DateTime end, const System::SharedPtr<Calendar>& anotherCalendar);
    ASPOSE_TASKS_SHARED_API System::TimeSpan GetWork(System::DateTime start, System::DateTime end, System::SharedPtr<Calendar> anotherCalendar, bool trimSeconds);
    /// <summary>
    /// Calculates next working time start beginning from the date and time.
    /// </summary>
    /// <param name="date">The date and time.</param>
    /// <returns>Next working time start.</returns>
    ASPOSE_TASKS_SHARED_API System::DateTime GetWorkStart(System::DateTime date);
    ASPOSE_TASKS_SHARED_API System::DateTime GetWorkStartOrDefault(System::DateTime date);
    ASPOSE_TASKS_SHARED_API System::DateTime GetWorkStart(System::DateTime date, const System::SharedPtr<Calendar>& anotherCalendar);
    ASPOSE_TASKS_SHARED_API System::DateTime GetPrevWorkingTimeEnd(System::DateTime date);
    ASPOSE_TASKS_SHARED_API bool IsEmpty();
    ASPOSE_TASKS_SHARED_API bool IsWorkDayEnd(System::DateTime date);
    ASPOSE_TASKS_SHARED_API bool IsWorkingTimeEnd(System::DateTime date);
    ASPOSE_TASKS_SHARED_API bool IsWorkDayStart(System::DateTime date);
    ASPOSE_TASKS_SHARED_API bool IsNonworkingTime(System::DateTime date);
    ASPOSE_TASKS_SHARED_API bool IsWorkingTimeStart(System::DateTime date);
    ASPOSE_TASKS_SHARED_API System::DateTime GetNextDayStart(System::DateTime date);
    ASPOSE_TASKS_SHARED_API System::DateTime GetNextDayStart(System::DateTime date, System::TimeSpan nonWorkingDayStart);
    ASPOSE_TASKS_SHARED_API System::DateTime GetDayStart(System::DateTime date);
    ASPOSE_TASKS_SHARED_API int32_t GetWorkingDaysCount(System::DateTime start, System::DateTime end);
    /// <summary>
    /// Calculates the date when the specified amount of work time will pass according to the calendar and another calendar (resource calendar, for example)
    /// </summary>
    /// <param name="start">Start date.</param>
    /// <param name="work">Amount of work.</param>
    /// <param name="anotherCalendar">Another calendar that must not be ignored.</param>
    /// <returns>Calculated finish date.</returns>
    ASPOSE_TASKS_SHARED_API System::DateTime GetFinishDateByStartAndWork(System::DateTime start, System::TimeSpan work, const System::SharedPtr<Calendar>& anotherCalendar);
    ASPOSE_TASKS_SHARED_API System::DateTime GetStartDateByFinishAndWork(System::DateTime finish, Duration work, const System::SharedPtr<Calendar>& anotherCalendar);
    /// <summary>
    /// Calculates the date when the specified amount of work time will pass according to the calendar and another calendar (resource calendar, for example)
    /// </summary>
    /// <param name="finish">Finish date.</param>
    /// <param name="work">Amount of work.</param>
    /// <param name="anotherCalendar">Another calendar that must not be ignored.</param>
    /// <returns>Calculated start date.</returns>
    ASPOSE_TASKS_SHARED_API System::DateTime GetStartDateByFinishAndWork(System::DateTime finish, System::TimeSpan work, const System::SharedPtr<Calendar>& anotherCalendar);
    /// <summary>
    /// Calculates the date when the specified amount of work time will pass according to the calendar and another calendar (resource calendar, for example)
    /// </summary>
    /// <param name="finish">Finish date.</param>
    /// <param name="work">Amount of work.</param>
    /// <returns>Calculated start date.</returns>
    ASPOSE_TASKS_SHARED_API System::DateTime GetStartDateByFinishAndWork(System::DateTime finish, System::TimeSpan work);
    /// <summary>
    /// Gets working times at the specified date "intersected" with the date's TimeOfDay. 
    /// </summary>
    ASPOSE_TASKS_SHARED_API System::SharedPtr<WorkingTimeCollection> GetWorkingTimesAtDate(System::DateTime date);
    ASPOSE_TASKS_SHARED_API void StartExceptionsCaching();
    ASPOSE_TASKS_SHARED_API void StopExceptionsCaching();
    /// <summary>
    /// Creates default standard calendar.
    /// </summary>
    /// <returns>Created calendar.</returns>
    static ASPOSE_TASKS_SHARED_API System::SharedPtr<Calendar> MakeStandardCalendarNoWeekend();
    ASPOSE_TASKS_SHARED_API void SetWorkingExceptions(const System::SharedPtr<TimeScaledExceptions>& exceptionCollection);
    /// <summary>
    /// Creates default standard calendar.
    /// </summary>
    /// <returns>Created calendar.</returns>
    static ASPOSE_TASKS_SHARED_API System::SharedPtr<Calendar> Get24HoursCalendarInternal();
    static ASPOSE_TASKS_SHARED_API System::SharedPtr<Calendar> WrapCalendar(const System::SharedPtr<Calendar>& calendar, const System::SharedPtr<TimeScaledExceptions>& workingExceptions);
    /// <summary>
    /// Creates default standard calendar.
    /// </summary>
    /// <returns>Created calendar.</returns>
    static ASPOSE_TASKS_SHARED_API System::SharedPtr<Calendar> MakeStandardCalendarInternal();
    ASPOSE_TASKS_SHARED_API System::SharedPtr<WorkingTimeCollection> GetWorkingTimesIgnoreExceptions(DayType dayType);
    ASPOSE_TASKS_SHARED_API System::SharedPtr<CalendarException> CheckException(System::DateTime dt, bool checkImplicit = true);
    ASPOSE_TASKS_SHARED_API System::SharedPtr<IReadOnlyWorkingTimeCollection> GetScheduleForImplicitException();
    
    virtual ASPOSE_TASKS_SHARED_API ~Calendar();
    
    #ifdef ASPOSE_GET_SHARED_MEMBERS
    ASPOSE_TASKS_SHARED_API void GetSharedMembers(System::Object::shared_members_type& result) const override;
    #endif
    
    
private:
 
    System::SharedPtr<CalendarDatesCalculator> calculator;
    System::SharedPtr<CalendarExceptionCollectionWithCache> exceptions;
    System::SharedPtr<TimeScaledExceptions> workingExceptions;
    NullableBool isBaselineCalendar;
    System::WeakPtr<Aspose::Tasks::Resource> resource;
    System::Nullable<bool> is24HourCal;
    System::SharedPtr<Calendar> baseCalendar;
    System::String guid;
    int32_t isCacheEnabledNesting;
    System::SharedPtr<IKeyValueCache<System::DateTime, System::SharedPtr<WorkingTimeCollection>>> calculationsCache;
    
    static System::SharedPtr<Calendar>& calendar24Hours();
    
    System::String pr_Name;
    int32_t pr_Uid;
    System::SharedPtr<WeekDayCollection> pr_WeekDays;
    System::SharedPtr<WorkWeekCollection> pr_WorkWeeks;
    
    /// <summary>
    /// Gets WorkWeekCollections object.
    /// The collection of work weeks that is associated with the calendar.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_WorkWeeks(const System::SharedPtr<WorkWeekCollection>& value);
    
    System::WeakPtr<Project> pr_ParentProject;
    int32_t pr_ResourceUid;
    bool pr_IsNull;
    System::Guid pr_UnknownGuid;
    
    System::String get_DebuggerDisplay();
    /// <summary>
    /// Gets a value indicating whether the calendar is 'uniform' (work times are the same for days with the same DayOfWeek). 
    /// </summary>
    bool get_IsUniform();
    
    void TryToSkipByWeek(System::DateTime& enumeratorStartDate, int64_t& totalSpan, System::DateTime finish);
    System::TimeSpan GetWorkingHoursInDay(System::DateTime start, System::DateTime finish);
    void InitScheduleForTimescaledException(const System::SharedPtr<CalendarException>& exception, System::DateTime dt);
    static void Make24HourWeek(const System::SharedPtr<Calendar>& calendar);
    System::TimeSpan GetWeekTotalWork();
    bool CheckWeekHasNoExceptions(System::DateTime start, System::DateTime finish);
    static void MakeNightShiftWeek(const System::SharedPtr<Calendar>& calendar);
    System::SharedPtr<WorkingTimeCollection> CalculateWorkingTimes(System::DateTime dt);
    System::SharedPtr<WorkingTimeCollection> GetWorkingTimesForCalendarException(const System::SharedPtr<CalendarException>& calendarException, System::DateTime dt);
    System::SharedPtr<WeekDay> GetWeekDay(System::DateTime dt);
    System::SharedPtr<WeekDay> CheckWeekDay(DayType dayType);
    System::SharedPtr<WeekDay> CheckDateInWorkWeeks(System::DateTime dt);
    
};
 
ASPOSE_TASKS_SHARED_API bool operator ==(Calendar::CalendarCacheKey left, Calendar::CalendarCacheKey right);
ASPOSE_TASKS_SHARED_API bool operator !=(Calendar::CalendarCacheKey left, Calendar::CalendarCacheKey right);
 
} // namespace Tasks
} // namespace Aspose