CalendarException.h

#pragma once
//-----------------------------------------------------------------------
// <copyright file="CalendarException.cs" company="Aspose Pty Ltd">
//   Copyright (c) 2002-2024 Aspose Pty Ltd. All Rights Reserved.
// </copyright>
//-----------------------------------------------------------------------
 
#include <system/string.h>
#include <system/date_time.h>
#include <cstdint>
 
#include "aspose.tasks.cpp/aspose_tasks_api_defs.h"
 
namespace Aspose
{
namespace Tasks
{
class Calendar;
class CalendarExceptionCalculator;
class CalendarExceptionCollection;
class CalendarExceptionCollectionWithCache;
class CalendarExceptionDatesCalculator;
enum class CalendarExceptionType;
class DayTypeCollection;
namespace IO
{
namespace Html
{
class HtmlCalendarExceptionsReader;
} // namespace Html
namespace MSProject
{
class Mpp12CalendarWriter;
class Mpp12ExceptionReader;
} // namespace MSProject
namespace Xml
{
class ExceptionNodeReader;
class ExceptionNodeWriter;
} // namespace Xml
} // namespace IO
enum class Month;
enum class MonthItemType;
enum class MonthPosition;
namespace Saving
{
class HtmlCalendarExceptionTable;
} // namespace Saving
class TimeScaledExceptions;
class WorkingTimeCollection;
} // namespace Tasks
} // namespace Aspose
namespace System
{
namespace Collections
{
namespace Generic
{
template <typename> class IEnumerable;
} // namespace Generic
} // namespace Collections
class TimeSpan;
} // namespace System
 
namespace Aspose {
 
namespace Tasks {
 
/// <summary>
/// Represent exceptional time periods in a calendar.
/// </summary>
class ASPOSE_TASKS_SHARED_CLASS CalendarException final : public System::Object
{
    typedef CalendarException ThisType;
    typedef System::Object BaseType;
    
    typedef ::System::BaseTypesInfo<BaseType> ThisTypeBaseTypesInfo;
    ASPOSE_TASKS_SHARED_RTTI_INFO_DECL();
    
    friend class Aspose::Tasks::Calendar;
    friend class Aspose::Tasks::CalendarExceptionCalculator;
    friend class Aspose::Tasks::CalendarExceptionCollection;
    friend class Aspose::Tasks::CalendarExceptionCollectionWithCache;
    friend class Aspose::Tasks::CalendarExceptionDatesCalculator;
    friend class Aspose::Tasks::IO::Html::HtmlCalendarExceptionsReader;
    friend class Aspose::Tasks::IO::MSProject::Mpp12ExceptionReader;
    friend class Aspose::Tasks::IO::MSProject::Mpp12CalendarWriter;
    friend class Aspose::Tasks::IO::Xml::ExceptionNodeReader;
    friend class Aspose::Tasks::IO::Xml::ExceptionNodeWriter;
    friend class Aspose::Tasks::Saving::HtmlCalendarExceptionTable;
    friend class Aspose::Tasks::TimeScaledExceptions;
    
public:
 
    /// <summary>
    /// Gets a value indicating whether the range of recurrence is defined by entering a number of occurrences.
    /// False specifies that the range of recurrence is defined by entering a finish date.
    /// </summary>
    ASPOSE_TASKS_SHARED_API bool get_EnteredByOccurrences() const;
    /// <summary>
    /// Sets a value indicating whether the range of recurrence is defined by entering a number of occurrences.
    /// False specifies that the range of recurrence is defined by entering a finish date.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_EnteredByOccurrences(bool value);
    /// <summary>
    /// Gets the beginning of the exception time.
    /// </summary>
    ASPOSE_TASKS_SHARED_API System::DateTime get_FromDate() const;
    /// <summary>
    /// Sets the beginning of the exception time.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_FromDate(System::DateTime value);
    /// <summary>
    /// Gets the end of the exception time.
    /// </summary>
    ASPOSE_TASKS_SHARED_API System::DateTime get_ToDate() const;
    /// <summary>
    /// Sets the end of the exception time.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_ToDate(System::DateTime value);
    /// <summary>
    /// Gets the number of occurrences for which the calendar exception is valid.
    /// </summary>
    ASPOSE_TASKS_SHARED_API int32_t get_Occurrences() const;
    /// <summary>
    /// Sets the number of occurrences for which the calendar exception is valid.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_Occurrences(int32_t value);
    /// <summary>
    /// Gets the name of the exception.
    /// </summary>
    ASPOSE_TASKS_SHARED_API System::String get_Name() const;
    /// <summary>
    /// Sets the name of the exception.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_Name(const System::String& value);
    /// <summary>
    /// Gets the exception type.
    /// </summary>
    ASPOSE_TASKS_SHARED_API CalendarExceptionType get_Type() const;
    /// <summary>
    /// Sets the exception type.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_Type(CalendarExceptionType value);
    /// <summary>
    /// Gets the period of recurrence for the exception.
    /// </summary>
    ASPOSE_TASKS_SHARED_API int32_t get_Period() const;
    /// <summary>
    /// Sets the period of recurrence for the exception.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_Period(int32_t value);
    /// <summary>
    /// Gets the DayTypeCollection for this object.
    /// The days of the week on which the exception is valid.
    /// </summary>
    ASPOSE_TASKS_SHARED_API const System::SharedPtr<DayTypeCollection>& get_DaysOfWeek() const;
    /// <summary>
    /// Gets the month item for which an exception recurrence is scheduled.
    /// </summary>
    ASPOSE_TASKS_SHARED_API MonthItemType get_MonthItem() const;
    /// <summary>
    /// Sets the month item for which an exception recurrence is scheduled.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_MonthItem(MonthItemType value);
    /// <summary>
    /// Gets the position of a month item within a month.
    /// </summary>
    ASPOSE_TASKS_SHARED_API Aspose::Tasks::MonthPosition get_MonthPosition() const;
    /// <summary>
    /// Sets the position of a month item within a month.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_MonthPosition(Aspose::Tasks::MonthPosition value);
    /// <summary>
    /// Gets the month for which an exception recurrence is scheduled.
    /// </summary>
    ASPOSE_TASKS_SHARED_API Aspose::Tasks::Month get_Month() const;
    /// <summary>
    /// Sets the month for which an exception recurrence is scheduled.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_Month(Aspose::Tasks::Month value);
    /// <summary>
    /// Gets the day of a month on which an exception recurrence is scheduled.
    /// </summary>
    ASPOSE_TASKS_SHARED_API int32_t get_MonthDay() const;
    /// <summary>
    /// Sets the day of a month on which an exception recurrence is scheduled.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_MonthDay(int32_t value);
    /// <summary>
    /// Gets a value indicating whether the specified date or day type is working.
    /// </summary>
    ASPOSE_TASKS_SHARED_API bool get_DayWorking() const;
    /// <summary>
    /// Sets a value indicating whether the specified date or day type is working.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_DayWorking(bool value);
    /// <summary>
    /// Gets the WorkingTimeCollection object.
    /// The collection of working times that defines the time worked on the weekday.
    /// <remarks>
    /// At least one working time must present, and there can't be more than five.
    /// </remarks>
    /// </summary>
    ASPOSE_TASKS_SHARED_API const System::SharedPtr<WorkingTimeCollection>& get_WorkingTimes() const;
    /// <summary>
    /// Sets the WorkingTimeCollection object.
    /// The collection of working times that defines the time worked on the weekday.
    /// <remarks>
    /// At least one working time must present, and there can't be more than five.
    /// </remarks>
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_WorkingTimes(const System::SharedPtr<WorkingTimeCollection>& value);
    /// <summary>
    /// Gets the parent calendar for this object.
    /// </summary>
    ASPOSE_TASKS_SHARED_API const System::SharedPtr<Calendar>& get_ParentCalendar() const;
    
    /// <summary>
    /// Initializes a new instance of the <see cref="CalendarException"></see> class.
    /// </summary>
    ASPOSE_TASKS_SHARED_API CalendarException();
    
    /// <summary>
    /// Deletes the Exception instance from parent calendar CalendarExceptionCollection object.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void Delete();
    /// <summary>
    /// Returns true if the specified instance of the <see cref="DateTime"></see> struct is the exception day.
    /// </summary>
    /// <param name="dt">the specified instance of the <see cref="DateTime"></see> struct.</param>
    /// <returns> Returns true if <see cref="DateTime"></see> value is the exception day; otherwise, false.</returns>
    ASPOSE_TASKS_SHARED_API bool CheckException(System::DateTime dt);
    /// <summary>
    /// Returns the working time for a calendar exception.
    /// </summary>
    /// <returns>Returns working time for this calendar exception.</returns>
    ASPOSE_TASKS_SHARED_API System::TimeSpan GetWorkingTime();
    /// <summary>
    /// Returns dates on which the calendar exception is applicable. 
    /// </summary>
    /// <returns> Returns a collection of exception dates the calendar exception is applicable for.</returns>
    ASPOSE_TASKS_SHARED_API System::SharedPtr<System::Collections::Generic::IEnumerable<System::DateTime>> GetExceptionDates();
    
protected:
 
    /// <summary>
    /// Gets the DayTypeCollection for this object.
    /// The days of the week on which the exception is valid.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_DaysOfWeek(const System::SharedPtr<DayTypeCollection>& value);
    /// <summary>
    /// Gets the parent calendar for this object.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_ParentCalendar(const System::SharedPtr<Calendar>& value);
    ASPOSE_TASKS_SHARED_API bool get_IsImplicitWorkingTimeException() const;
    ASPOSE_TASKS_SHARED_API bool get_IsUnresolvedTimephasedIntervalException() const;
    ASPOSE_TASKS_SHARED_API void set_IsUnresolvedTimephasedIntervalException(bool value);
    static ASPOSE_TASKS_SHARED_API System::SharedPtr<CalendarException> get_ImplicitWorkingTimeException();
    
    /// <summary>
    /// Initializes a new instance of the <see cref="CalendarException"></see> class.
    /// </summary>
    ASPOSE_TASKS_SHARED_API CalendarException(const System::SharedPtr<WorkingTimeCollection>& workingTimeCollection);
    
    ASPOSE_TASKS_SHARED_API MEMBER_FUNCTION_MAKE_OBJECT_DECLARATION(CalendarException, CODEPORTING_ARGS(const System::SharedPtr<WorkingTimeCollection>& workingTimeCollection));
    static ASPOSE_TASKS_SHARED_API System::SharedPtr<CalendarException> CreateTimescaledWorkingIntervalException(System::DateTime start, System::TimeSpan end);
    /// <summary>
    /// Returns true if the specified instance of the <see cref="DateTime"></see> struct is the exception day.
    /// </summary>
    /// <param name="dt">the specified instance of the <see cref="DateTime"></see> struct.</param>
    /// <returns>Returns true if <see cref="DateTime"></see> value is the exception day; otherwise, false.</returns>
    ASPOSE_TASKS_SHARED_API bool CheckExceptionOnDate(System::DateTime dt);
    
    virtual ASPOSE_TASKS_SHARED_API ~CalendarException();
    
    #ifdef ASPOSE_GET_SHARED_MEMBERS
    ASPOSE_TASKS_SHARED_API void GetSharedMembers(System::Object::shared_members_type& result) const override;
    #endif
    
    
private:
 
    static const int32_t MaxNameLength;
    int32_t occurrences;
    System::String name;
    bool isImplicitWorkingTimeException;
    
    static System::SharedPtr<CalendarException>& implicitWorkingTimeExceptionInstance();
    
    bool pr_EnteredByOccurrences;
    System::DateTime pr_FromDate;
    System::DateTime pr_ToDate;
    CalendarExceptionType pr_Type;
    int32_t pr_Period;
    System::SharedPtr<DayTypeCollection> pr_DaysOfWeek;
    MonthItemType pr_MonthItem;
    Aspose::Tasks::MonthPosition pr_MonthPosition;
    Aspose::Tasks::Month pr_Month;
    int32_t pr_MonthDay;
    bool pr_DayWorking;
    System::SharedPtr<WorkingTimeCollection> pr_WorkingTimes;
    System::WeakPtr<Calendar> pr_ParentCalendar;
    bool pr_IsUnresolvedTimephasedIntervalException;
    
};
 
} // namespace Tasks
} // namespace Aspose