ResourceAssignment.h

#pragma once
//-----------------------------------------------------------------------
// <copyright file="ResourceAssignment.cs" company="Aspose Pty Ltd">
//   Copyright (c) 2002-2025 Aspose Pty Ltd. All Rights Reserved.
// </copyright>
//-----------------------------------------------------------------------
 
#include <system/object_ext.h>
#include <system/nullable.h>
#include <system/multicast_delegate.h>
#include <system/iequatable.h>
#include <system/guid.h>
#include <system/array.h>
#include <cstdint>
 
#include "aspose.tasks.cpp/aspose_tasks_api_defs.h"
#include "aspose.tasks.cpp/IEntityWithNotes.h"
#include "aspose.tasks.cpp/IEntityWithHyperlink.h"
#include "aspose.tasks.cpp/IContainer.h"
#include "aspose.tasks.cpp/Enums/AsnKey.h"
#include "aspose.tasks.cpp/IExtendedAttributeParent.h"
#include "aspose.tasks.cpp/IEntityWithTd.h"
#include "aspose.tasks.cpp/Task.h"
#include "aspose.tasks.cpp/Resource.h"
#include "aspose.tasks.cpp/Key.h"
#include "aspose.tasks.cpp/PropertyContainer.h"
 
namespace Aspose
{
namespace Tasks
{
class AssignmentBaseline;
class AssignmentBaselineCollection;
class AutoRecalculationState;
enum class BaselineType;
enum class BookingType;
namespace Calculations
{
class ActualsByPercentCompleteUpdater;
class ActualTimephasedDataUpdater;
class AssignmentProjection;
class IWorkContourIterator;
class RescheduleIncompleteWorkCalculator;
class ResourceAssignmentCalculator;
class ResourceAssignmentCostCalculator;
class ResourceAssignmentPeakCalculator;
class ResourceAssignmentRateByDateEnumerator;
class ResourceAssignmentVarianceCalculator;
class ResourceAssignmentWorkCalculator;
class ResourceOverAllocationCalculator;
class ResourceWorkCalculator;
class TaskByAssignmentCalculator;
class TaskCalculator;
class TaskStopResumeCalculator;
class TimephasedDataCalculator;
} // namespace Calculations
class Calendar;
namespace Connectivity
{
class MpdAssignmentBaselineMapper;
class MpdAssignmentMapper;
template <typename> class MpdField;
class MspAssignmentBaseLineMapper;
class MspAssignmentMapper;
class PmResourceAssignmentMapper;
} // namespace Connectivity
class DatesCalculator;
class Duration;
class EvaluationModeDatesResetter;
class EVCalculator;
class ExtendedAttributeCollection;
namespace Filters
{
class ResourceAssignmentValidByTaskFilter;
class ResourceAssignmentValidMaterialByTaskFilter;
class ResourceAssignmentValidWorkByTaskFilter;
} // namespace Filters
class FixedDurationEffortDrivenTaskPlanner;
class FixedDurationTaskPlanner;
class FixedWorkTaskPlanner;
namespace IO
{
namespace Html
{
class HtmlResourceAssignmentBaseLineTableReader;
class HtmlResourceAssignmentTableReader;
} // namespace Html
namespace MSProject
{
namespace Metadata
{
class AssignmentExtendedAttributeFlagOffsets;
} // namespace Metadata
class MPP12Reader;
class MPP12ResourceAssignmentWriter;
template <typename> class MPP14AsXResourceAssignmentReader;
class MPP14Reader;
class MPP14ResourceAssignmentWriter;
class MPP14TaskWriter;
class MPP9Reader;
class MPP9ResourceAssignmentReader;
class MPP9ResourceAssignmentWriter;
class MPPAssignmentExtendedAttributeReader;
class MPPReader;
class MPPResourceAssignmentWriter;
class MPPTimephasedDataReader;
class MppTimephasedDataWriter;
} // namespace MSProject
namespace PrimaveraXml
{
class PrimaveraAssignmentsNodeReader;
} // namespace PrimaveraXml
namespace Pwa
{
namespace InternalApi
{
namespace Mapping
{
class AssignmentContourDataMapper;
template <typename> class BinaryDataPropertyMapper;
template <typename> class ExtendedAttributeParentEntityToRawValuesMapper;
class ProjectAssignmentsMapper;
} // namespace Mapping
} // namespace InternalApi
} // namespace Pwa
namespace Xer
{
class XerAssignmentReader;
} // namespace Xer
namespace Xml
{
class ResourceAssignmentFactory;
class ResourceAssignmentNodeReader;
class ResourceAssignmentNodeWriter;
} // namespace Xml
} // namespace IO
namespace Leveling
{
class LevelingAlgorithm;
} // namespace Leveling
class ManualState;
class PercentCompleteCalculator;
class Project;
class ProjectState;
class ProjectWorkUpdater;
class Rate;
enum class RateScaleType;
enum class RateType;
namespace Recalculation
{
class TaskSplitCalculator;
} // namespace Recalculation
class ResourceAssignmentCollection;
class ResourceAssignmentTimephasedDataCollection;
namespace Saving
{
class HtmlResourceAssignmentBaseLineTable;
class PrimaveraAssignmentNodeWriter;
class TemplateWriter;
class XerAssignmentTable;
} // namespace Saving
namespace Scheduling
{
class FromFinishScheduler;
class FromStartScheduler;
} // namespace Scheduling
class SplitPartCollection;
class SplitsCalculator;
class TaskBaselineCollection;
class TaskPlanner;
class TaskPlannerAssignmentManager;
namespace Timephased
{
class TimephasedDataByScaledEnumerator;
class TimeScaledWorkContourBuilder;
} // namespace Timephased
class TimephasedData;
class TimephasedDataByScaledMaker;
class TimephasedDataCollection;
class TimephasedDataMaker;
enum class TimephasedDataType : int8_t;
class TimephasedWorkCostSelector;
class TimeScaledExceptions;
class TimeScaledParentWorkUnit;
class TimeScaledWorkUnit;
namespace Util
{
template <typename T> using ConditionDelegate = System::MulticastDelegate<bool(T)>;
class DateTimeInterval;
} // namespace Util
namespace Visualization
{
class ApsResourceUsageBuilder;
class ApsResourceUsagePage;
class ApsTaskUsageBuilder;
class ApsUsagePage;
class AssignmentToColumnText;
template <typename> class FieldToColumnText;
class TaskToColumnText;
} // namespace Visualization
enum class WorkContourType;
class WorkingTimeCollection;
} // namespace Tasks
} // namespace Aspose
namespace System
{
namespace Collections
{
namespace Generic
{
template <typename> class IEnumerable;
template <typename> class IList;
template <typename> class List;
} // namespace Generic
} // namespace Collections
class DateTime;
class Decimal;
class EventArgs;
class TimeSpan;
} // namespace System
 
namespace Aspose {
 
namespace Tasks {
 
/// <summary>
/// Represents a resource assignment in a project.
/// </summary>
class ASPOSE_TASKS_SHARED_CLASS ResourceAssignment : public IEntityWithNotes, public IEntityWithHyperlink, public IContainer<AsnKey>, public System::IEquatable<System::SharedPtr<ResourceAssignment>>, public IExtendedAttributeParent, public IEntityWithTd
{
    typedef ResourceAssignment ThisType;
    typedef IEntityWithNotes BaseType;
    typedef IEntityWithHyperlink BaseType1;
    typedef IContainer<AsnKey> BaseType2;
    typedef System::IEquatable<System::SharedPtr<ResourceAssignment>> BaseType3;
    typedef IExtendedAttributeParent BaseType4;
    typedef IEntityWithTd BaseType5;
    
    typedef ::System::BaseTypesInfo<BaseType, BaseType1, BaseType2, BaseType3, BaseType4, BaseType5> ThisTypeBaseTypesInfo;
    ASPOSE_TASKS_SHARED_RTTI_INFO_DECL();
    
    friend class Aspose::Tasks::Calculations::ResourceAssignmentRateByDateEnumerator;
    friend class Aspose::Tasks::Calculations::ResourceAssignmentCalculator;
    friend class Aspose::Tasks::IO::MSProject::MppTimephasedDataWriter;
    friend class Project;
    friend class FixedWorkTaskPlanner;
    template<typename FT0> friend class Aspose::Tasks::Visualization::FieldToColumnText;
    friend class Aspose::Tasks::Calculations::ResourceAssignmentWorkCalculator;
    friend class Aspose::Tasks::IO::MSProject::MPP9ResourceAssignmentWriter;
    friend class Aspose::Tasks::Calculations::TaskStopResumeCalculator;
    friend class EVCalculator;
    friend class Aspose::Tasks::IO::Pwa::InternalApi::Mapping::AssignmentContourDataMapper;
    friend class TimephasedDataByScaledMaker;
    friend class Aspose::Tasks::IO::MSProject::MPP12ResourceAssignmentWriter;
    friend class DatesCalculator;
    friend class Aspose::Tasks::IO::MSProject::MPP9ResourceAssignmentReader;
    friend class Aspose::Tasks::Leveling::LevelingAlgorithm;
    friend class Aspose::Tasks::Visualization::TaskToColumnText;
    friend class Aspose::Tasks::Filters::ResourceAssignmentValidMaterialByTaskFilter;
    friend class Aspose::Tasks::IO::MSProject::MPPAssignmentExtendedAttributeReader;
    friend class Aspose::Tasks::Calculations::ActualsByPercentCompleteUpdater;
    friend class ProjectWorkUpdater;
    friend class Aspose::Tasks::Calculations::ResourceWorkCalculator;
    friend class Aspose::Tasks::Visualization::AssignmentToColumnText;
    friend class Aspose::Tasks::Saving::TemplateWriter;
    friend class Aspose::Tasks::IO::MSProject::MPP12Reader;
    template<typename FT0> friend class Aspose::Tasks::IO::MSProject::MPP14AsXResourceAssignmentReader;
    friend class Aspose::Tasks::Task;
    template<typename FT0> friend class Aspose::Tasks::Connectivity::MpdField;
    friend class Aspose::Tasks::Calculations::TaskCalculator;
    friend class AutoRecalculationState;
    friend class EvaluationModeDatesResetter;
    friend class Aspose::Tasks::Connectivity::MpdAssignmentMapper;
    friend class Aspose::Tasks::Visualization::ApsTaskUsageBuilder;
    friend class Aspose::Tasks::IO::Pwa::InternalApi::Mapping::ProjectAssignmentsMapper;
    friend class Aspose::Tasks::IO::Xml::ResourceAssignmentFactory;
    friend class Aspose::Tasks::Calculations::RescheduleIncompleteWorkCalculator;
    friend class Aspose::Tasks::Saving::PrimaveraAssignmentNodeWriter;
    friend class Aspose::Tasks::IO::Html::HtmlResourceAssignmentTableReader;
    friend class Aspose::Tasks::Connectivity::MspAssignmentBaseLineMapper;
    friend class Aspose::Tasks::Connectivity::MpdAssignmentBaselineMapper;
    friend class AssignmentBaseline;
    friend class Aspose::Tasks::IO::MSProject::MPPTimephasedDataReader;
    friend class TaskPlannerAssignmentManager;
    friend class Aspose::Tasks::Calculations::ResourceAssignmentVarianceCalculator;
    friend class Aspose::Tasks::Recalculation::TaskSplitCalculator;
    friend class Aspose::Tasks::IO::MSProject::MPPResourceAssignmentWriter;
    friend class TimephasedWorkCostSelector;
    friend class TaskPlanner;
    friend class Aspose::Tasks::Calculations::ResourceAssignmentCostCalculator;
    friend class Aspose::Tasks::IO::Xml::ResourceAssignmentNodeReader;
    friend class Aspose::Tasks::Calculations::TaskByAssignmentCalculator;
    friend class Aspose::Tasks::IO::MSProject::MPPReader;
    friend class TaskBaselineCollection;
    friend class Aspose::Tasks::IO::MSProject::Metadata::AssignmentExtendedAttributeFlagOffsets;
    friend class Aspose::Tasks::IO::MSProject::MPP14ResourceAssignmentWriter;
    friend class Aspose::Tasks::IO::MSProject::MPP9Reader;
    friend class Aspose::Tasks::Calculations::ActualTimephasedDataUpdater;
    friend class TimephasedDataMaker;
    template<typename FT0> friend class Aspose::Tasks::IO::Pwa::InternalApi::Mapping::BinaryDataPropertyMapper;
    friend class Aspose::Tasks::Scheduling::FromFinishScheduler;
    friend class Aspose::Tasks::IO::Xml::ResourceAssignmentNodeWriter;
    friend class ManualState;
    friend class Aspose::Tasks::Visualization::ApsResourceUsageBuilder;
    template<typename FT0> friend class Aspose::Tasks::IO::Pwa::InternalApi::Mapping::ExtendedAttributeParentEntityToRawValuesMapper;
    friend class Aspose::Tasks::Connectivity::MspAssignmentMapper;
    friend class FixedDurationTaskPlanner;
    friend class Aspose::Tasks::IO::Xer::XerAssignmentReader;
    friend class Aspose::Tasks::IO::Html::HtmlResourceAssignmentBaseLineTableReader;
    friend class ResourceAssignmentCollection;
    friend class Aspose::Tasks::Connectivity::PmResourceAssignmentMapper;
    friend class Aspose::Tasks::Calculations::ResourceAssignmentPeakCalculator;
    friend class Aspose::Tasks::IO::MSProject::MPP14TaskWriter;
    friend class Aspose::Tasks::Visualization::ApsUsagePage;
    friend class Aspose::Tasks::IO::MSProject::MPP14Reader;
    friend class SplitsCalculator;
    friend class Aspose::Tasks::Saving::HtmlResourceAssignmentBaseLineTable;
    friend class Aspose::Tasks::IO::PrimaveraXml::PrimaveraAssignmentsNodeReader;
    friend class FixedDurationEffortDrivenTaskPlanner;
    friend class Aspose::Tasks::Calculations::ResourceOverAllocationCalculator;
    friend class Aspose::Tasks::Calculations::AssignmentProjection;
    friend class Aspose::Tasks::Calculations::TimephasedDataCalculator;
    friend class Aspose::Tasks::Scheduling::FromStartScheduler;
    friend class PercentCompleteCalculator;
    friend class Aspose::Tasks::Filters::ResourceAssignmentValidByTaskFilter;
    friend class ResourceAssignmentTimephasedDataCollection;
    friend class ProjectState;
    friend class Aspose::Tasks::Timephased::TimephasedDataByScaledEnumerator;
    friend class Aspose::Tasks::Filters::ResourceAssignmentValidWorkByTaskFilter;
    friend class Aspose::Tasks::Visualization::ApsResourceUsagePage;
    friend class Aspose::Tasks::Saving::XerAssignmentTable;
    friend class Aspose::Tasks::Timephased::TimeScaledWorkContourBuilder;
    
public:
 
    /// <summary>
    /// Gets a value of Uid.
    /// </summary>
    ASPOSE_TASKS_SHARED_API int32_t get_Uid() override;
    /// <summary>
    /// Sets a value of Uid.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_Uid(int32_t value);
    /// <summary>
    /// Gets a value of PercentWorkComplete.
    /// </summary>
    ASPOSE_TASKS_SHARED_API int32_t get_PercentWorkComplete();
    /// <summary>
    /// Sets a value of PercentWorkComplete.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_PercentWorkComplete(int32_t value);
    /// <summary>
    /// Gets a value of ActualCost.
    /// </summary>
    ASPOSE_TASKS_SHARED_API System::Decimal get_ActualCost();
    /// <summary>
    /// Sets a value of ActualCost.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_ActualCost(System::Decimal value);
    /// <summary>
    /// Gets a value of ActualFinish.
    /// </summary>
    ASPOSE_TASKS_SHARED_API System::DateTime get_ActualFinish();
    /// <summary>
    /// Sets a value of ActualFinish.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_ActualFinish(System::DateTime value);
    /// <summary>
    /// Gets a value of ActualOvertimeCost.
    /// </summary>
    ASPOSE_TASKS_SHARED_API System::Decimal get_ActualOvertimeCost();
    /// <summary>
    /// Sets a value of ActualOvertimeCost.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_ActualOvertimeCost(System::Decimal value);
    /// <summary>
    /// Gets a value of ActualStart.
    /// </summary>
    ASPOSE_TASKS_SHARED_API System::DateTime get_ActualStart();
    /// <summary>
    /// Sets a value of ActualStart.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_ActualStart(System::DateTime value);
    /// <summary>
    /// Gets a value of ActualWork.
    /// </summary>
    ASPOSE_TASKS_SHARED_API Duration get_ActualWork();
    /// <summary>
    /// Sets a value of ActualWork.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_ActualWork(Duration value);
    /// <summary>
    /// Gets a value of ACWP.
    /// </summary>
    ASPOSE_TASKS_SHARED_API double get_ACWP();
    /// <summary>
    /// Sets a value of ACWP.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_ACWP(double value);
    /// <summary>
    /// Gets a value indicating whether Confirmed is set or not.
    /// </summary>
    ASPOSE_TASKS_SHARED_API bool get_Confirmed();
    /// <summary>
    /// Sets a value indicating whether Confirmed is set or not.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_Confirmed(bool value);
    /// <summary>
    /// Gets a value of Cost.
    /// </summary>
    ASPOSE_TASKS_SHARED_API System::Decimal get_Cost();
    /// <summary>
    /// Sets a value of Cost.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_Cost(System::Decimal value);
    /// <summary>
    /// Gets a value of CostRateTableType.
    /// </summary>
    ASPOSE_TASKS_SHARED_API RateType get_CostRateTableType();
    /// <summary>
    /// Sets a value of CostRateTableType.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_CostRateTableType(RateType value);
    /// <summary>
    /// Gets a value of CostVariance.
    /// </summary>
    ASPOSE_TASKS_SHARED_API double get_CostVariance();
    /// <summary>
    /// Sets a value of CostVariance.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_CostVariance(double value);
    /// <summary>
    /// Gets a value of CV.
    /// </summary>
    ASPOSE_TASKS_SHARED_API double get_CV();
    /// <summary>
    /// Sets a value of CV.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_CV(double value);
    /// <summary>
    /// Gets a value of Delay.
    /// </summary>
    ASPOSE_TASKS_SHARED_API Duration get_Delay();
    /// <summary>
    /// Sets a value of Delay.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_Delay(Duration value);
    /// <summary>
    /// Gets a value of Finish.
    /// </summary>
    ASPOSE_TASKS_SHARED_API System::DateTime get_Finish();
    /// <summary>
    /// Sets a value of Finish.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_Finish(System::DateTime value);
    /// <summary>
    /// Gets a value of FinishVariance.
    /// </summary>
    ASPOSE_TASKS_SHARED_API Duration get_FinishVariance();
    /// <summary>
    /// Sets a value of FinishVariance.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_FinishVariance(Duration value);
    /// <summary>
    /// Gets a value of Hyperlink.
    /// </summary>
    ASPOSE_TASKS_SHARED_API System::String get_Hyperlink() override;
    /// <summary>
    /// Sets a value of Hyperlink.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_Hyperlink(System::String value) override;
    /// <summary>
    /// Gets a value of HyperlinkAddress.
    /// </summary>
    ASPOSE_TASKS_SHARED_API System::String get_HyperlinkAddress() override;
    /// <summary>
    /// Sets a value of HyperlinkAddress.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_HyperlinkAddress(System::String value) override;
    /// <summary>
    /// Gets a value of HyperlinkSubAddress.
    /// </summary>
    ASPOSE_TASKS_SHARED_API System::String get_HyperlinkSubAddress() override;
    /// <summary>
    /// Sets a value of HyperlinkSubAddress.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_HyperlinkSubAddress(System::String value) override;
    /// <summary>
    /// Gets a value of WorkVariance.
    /// </summary>
    ASPOSE_TASKS_SHARED_API Duration get_WorkVariance();
    /// <summary>
    /// Sets a value of WorkVariance.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_WorkVariance(Duration value);
    /// <summary>
    /// Gets a value indicating whether HasFixedRateUnits is set or not.
    /// </summary>
    ASPOSE_TASKS_SHARED_API bool get_HasFixedRateUnits();
    /// <summary>
    /// Sets a value indicating whether HasFixedRateUnits is set or not.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_HasFixedRateUnits(bool value);
    /// <summary>
    /// Gets a value indicating whether FixedMaterial is set or not.
    /// </summary>
    ASPOSE_TASKS_SHARED_API bool get_FixedMaterial();
    /// <summary>
    /// Sets a value indicating whether FixedMaterial is set or not.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_FixedMaterial(bool value);
    /// <summary>
    /// Gets a value of LevelingDelay.
    /// </summary>
    ASPOSE_TASKS_SHARED_API Duration get_LevelingDelay();
    /// <summary>
    /// Sets a value of LevelingDelay.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_LevelingDelay(Duration value);
    /// <summary>
    /// Gets a value indicating whether LinkedFields is set or not.
    /// </summary>
    ASPOSE_TASKS_SHARED_API bool get_LinkedFields();
    /// <summary>
    /// Sets a value indicating whether LinkedFields is set or not.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_LinkedFields(bool value);
    /// <summary>
    /// Gets a value indicating whether Milestone is set or not.
    /// </summary>
    ASPOSE_TASKS_SHARED_API bool get_Milestone();
    /// <summary>
    /// Sets a value indicating whether Milestone is set or not.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_Milestone(bool value);
    /// <summary>
    /// Gets notes' plain text extracted from RTF data.
    /// </summary>
    ASPOSE_TASKS_SHARED_API System::String get_NotesText() override;
    /// <summary>
    /// Sets notes' plain text extracted from RTF data.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_NotesText(System::String value) override;
    /// <summary>
    /// Gets the text notes in RTF format.
    /// <remarks>Supported for MPP formats only.</remarks>
    /// </summary>
    ASPOSE_TASKS_SHARED_API System::String get_NotesRTF() override;
    /// <summary>
    /// Sets the text notes in RTF format.
    /// <remarks>Supported for MPP formats only.</remarks>
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_NotesRTF(System::String value) override;
    /// <summary>
    /// Gets a value indicating whether Overallocated is set or not.
    /// </summary>
    ASPOSE_TASKS_SHARED_API bool get_Overallocated();
    /// <summary>
    /// Sets a value indicating whether Overallocated is set or not.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_Overallocated(bool value);
    /// <summary>
    /// Gets a value of OvertimeCost.
    /// </summary>
    ASPOSE_TASKS_SHARED_API System::Decimal get_OvertimeCost();
    /// <summary>
    /// Sets a value of OvertimeCost.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_OvertimeCost(System::Decimal value);
    /// <summary>
    /// Gets a value of OvertimeWork.
    /// </summary>
    ASPOSE_TASKS_SHARED_API Duration get_OvertimeWork();
    /// <summary>
    /// Sets a value of OvertimeWork.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_OvertimeWork(Duration value);
    /// <summary>
    /// Gets a value of PeakUnits.
    /// </summary>
    ASPOSE_TASKS_SHARED_API double get_PeakUnits();
    /// <summary>
    /// Sets a value of PeakUnits.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_PeakUnits(double value);
    /// <summary>
    /// Gets a value of RegularWork.
    /// </summary>
    ASPOSE_TASKS_SHARED_API Duration get_RegularWork();
    /// <summary>
    /// Sets a value of RegularWork.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_RegularWork(Duration value);
    /// <summary>
    /// Gets a value of RemainingCost.
    /// </summary>
    ASPOSE_TASKS_SHARED_API System::Decimal get_RemainingCost();
    /// <summary>
    /// Sets a value of RemainingCost.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_RemainingCost(System::Decimal value);
    /// <summary>
    /// Gets a value of RemainingOvertimeCost.
    /// </summary>
    ASPOSE_TASKS_SHARED_API System::Decimal get_RemainingOvertimeCost();
    /// <summary>
    /// Sets a value of RemainingOvertimeCost.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_RemainingOvertimeCost(System::Decimal value);
    /// <summary>
    /// Gets a value of RemainingOvertimeWork.
    /// </summary>
    ASPOSE_TASKS_SHARED_API Duration get_RemainingOvertimeWork();
    /// <summary>
    /// Sets a value of RemainingOvertimeWork.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_RemainingOvertimeWork(Duration value);
    /// <summary>
    /// Gets a value of RemainingWork.
    /// </summary>
    ASPOSE_TASKS_SHARED_API Duration get_RemainingWork();
    /// <summary>
    /// Sets a value of RemainingWork.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_RemainingWork(Duration value);
    /// <summary>
    /// Gets a value indicating whether ResponsePending is set or not.
    /// </summary>
    ASPOSE_TASKS_SHARED_API bool get_ResponsePending();
    /// <summary>
    /// Sets a value indicating whether ResponsePending is set or not.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_ResponsePending(bool value);
    /// <summary>
    /// Gets a value of Start.
    /// </summary>
    ASPOSE_TASKS_SHARED_API System::DateTime get_Start() override;
    /// <summary>
    /// Sets a value of Start.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_Start(System::DateTime value);
    /// <summary>
    /// Gets a value of Stop.
    /// </summary>
    ASPOSE_TASKS_SHARED_API System::DateTime get_Stop();
    /// <summary>
    /// Sets a value of Stop.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_Stop(System::DateTime value);
    /// <summary>
    /// Gets a value of Resume.
    /// </summary>
    ASPOSE_TASKS_SHARED_API System::DateTime get_Resume();
    /// <summary>
    /// Sets a value of Resume.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_Resume(System::DateTime value);
    /// <summary>
    /// Gets a value of StartVariance.
    /// </summary>
    ASPOSE_TASKS_SHARED_API Duration get_StartVariance();
    /// <summary>
    /// Sets a value of StartVariance.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_StartVariance(Duration value);
    /// <summary>
    /// Gets a value indicating whether Summary is set or not.
    /// </summary>
    ASPOSE_TASKS_SHARED_API bool get_Summary();
    /// <summary>
    /// Sets a value indicating whether Summary is set or not.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_Summary(bool value);
    /// <summary>
    /// Gets a value of SV.
    /// </summary>
    ASPOSE_TASKS_SHARED_API double get_SV();
    /// <summary>
    /// Sets a value of SV.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_SV(double value);
    /// <summary>
    /// Gets a value of Units.
    /// </summary>
    ASPOSE_TASKS_SHARED_API double get_Units();
    /// <summary>
    /// Sets a value of Units.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_Units(double value);
    /// <summary>
    /// Gets a value indicating whether UpdateNeeded is set or not.
    /// </summary>
    ASPOSE_TASKS_SHARED_API bool get_UpdateNeeded();
    /// <summary>
    /// Sets a value indicating whether UpdateNeeded is set or not.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_UpdateNeeded(bool value);
    /// <summary>
    /// Gets a value of VAC.
    /// </summary>
    ASPOSE_TASKS_SHARED_API double get_VAC();
    /// <summary>
    /// Sets a value of VAC.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_VAC(double value);
    /// <summary>
    /// Gets a value of Work.
    /// </summary>
    ASPOSE_TASKS_SHARED_API Duration get_Work();
    /// <summary>
    /// Sets a value of Work.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_Work(Duration value);
    /// <summary>
    /// Gets a value of WorkContour.
    /// </summary>
    ASPOSE_TASKS_SHARED_API WorkContourType get_WorkContour();
    /// <summary>
    /// Sets a value of WorkContour.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_WorkContour(WorkContourType value);
    /// <summary>
    /// Gets a value of BCWS.
    /// </summary>
    ASPOSE_TASKS_SHARED_API double get_BCWS();
    /// <summary>
    /// Sets a value of BCWS.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_BCWS(double value);
    /// <summary>
    /// Gets a value of BCWP.
    /// </summary>
    ASPOSE_TASKS_SHARED_API double get_BCWP();
    /// <summary>
    /// Sets a value of BCWP.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_BCWP(double value);
    /// <summary>
    /// Gets a value of BookingType.
    /// </summary>
    ASPOSE_TASKS_SHARED_API Aspose::Tasks::BookingType get_BookingType();
    /// <summary>
    /// Sets a value of BookingType.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_BookingType(Aspose::Tasks::BookingType value);
    /// <summary>
    /// Gets a value of ActualWorkProtected.
    /// </summary>
    ASPOSE_TASKS_SHARED_API Duration get_ActualWorkProtected();
    /// <summary>
    /// Sets a value of ActualWorkProtected.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_ActualWorkProtected(Duration value);
    /// <summary>
    /// Gets a value of ActualOvertimeWorkProtected.
    /// </summary>
    ASPOSE_TASKS_SHARED_API Duration get_ActualOvertimeWorkProtected();
    /// <summary>
    /// Sets a value of ActualOvertimeWorkProtected.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_ActualOvertimeWorkProtected(Duration value);
    /// <summary>
    /// Gets a value of ActualOvertimeWork.
    /// </summary>
    ASPOSE_TASKS_SHARED_API Duration get_ActualOvertimeWork();
    /// <summary>
    /// Sets a value of ActualOvertimeWork.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_ActualOvertimeWork(Duration value);
    /// <summary>
    /// Gets a value of Created.
    /// </summary>
    ASPOSE_TASKS_SHARED_API System::DateTime get_Created();
    /// <summary>
    /// Sets a value of Created.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_Created(System::DateTime value);
    /// <summary>
    /// Gets a value of AssignmentOwner.
    /// </summary>
    ASPOSE_TASKS_SHARED_API System::String get_AssignmentOwner();
    /// <summary>
    /// Sets a value of AssignmentOwner.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_AssignmentOwner(const System::String& value);
    /// <summary>
    /// Gets a value of AssignmentOwnerGuid.
    /// </summary>
    ASPOSE_TASKS_SHARED_API System::String get_AssignmentOwnerGuid();
    /// <summary>
    /// Sets a value of AssignmentOwnerGuid.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_AssignmentOwnerGuid(const System::String& value);
    /// <summary>
    /// Gets a value of BudgetCost.
    /// </summary>
    ASPOSE_TASKS_SHARED_API System::Decimal get_BudgetCost();
    /// <summary>
    /// Sets a value of BudgetCost.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_BudgetCost(System::Decimal value);
    /// <summary>
    /// Gets a value of BudgetWork.
    /// </summary>
    ASPOSE_TASKS_SHARED_API Duration get_BudgetWork();
    /// <summary>
    /// Sets a value of BudgetWork.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_BudgetWork(Duration value);
    /// <summary>
    /// Gets a value of RateScale.
    /// </summary>
    ASPOSE_TASKS_SHARED_API RateScaleType get_RateScale();
    /// <summary>
    /// Sets a value of RateScale.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_RateScale(RateScaleType value);
    /// <summary>
    /// The task to which a resource is assigned.
    /// </summary>
    ASPOSE_TASKS_SHARED_API const System::SharedPtr<Aspose::Tasks::Task>& get_Task() const;
    /// <summary>
    /// The task to which a resource is assigned.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_Task(const System::SharedPtr<Aspose::Tasks::Task>& value);
    /// <summary>
    /// The resource assigned to a task.
    /// </summary>
    ASPOSE_TASKS_SHARED_API const System::SharedPtr<Aspose::Tasks::Resource>& get_Resource() const;
    /// <summary>
    /// The resource assigned to a task.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_Resource(const System::SharedPtr<Aspose::Tasks::Resource>& value);
    /// <summary>
    /// Gets unique identifier for this assignment.
    /// </summary>
    ASPOSE_TASKS_SHARED_API System::Nullable<System::Guid> get_Guid() const;
    /// <summary>
    /// Sets unique identifier for this assignment.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_Guid(System::Nullable<System::Guid> value);
    /// <summary>
    /// Gets parent project for this assignment.
    /// </summary>
    ASPOSE_TASKS_SHARED_API const System::SharedPtr<Project>& get_ParentProject() const override;
    /// <summary>
    /// Gets AssignmentBaselineCollection object.
    /// The collection of baseline values associated with an assignment.
    /// </summary>
    ASPOSE_TASKS_SHARED_API System::SharedPtr<AssignmentBaselineCollection> get_Baselines();
    /// <summary>
    /// Gets an instance of the ExtendedAttributeCollection class for this object.
    /// </summary>
    /// <remarks>Reading supported for XML format only.</remarks>
    ASPOSE_TASKS_SHARED_API System::SharedPtr<ExtendedAttributeCollection> get_ExtendedAttributes() override;
    /// <summary>
    /// Sets an instance of the ExtendedAttributeCollection class for this object.
    /// </summary>
    /// <remarks>Reading supported for XML format only.</remarks>
    ASPOSE_TASKS_SHARED_API void set_ExtendedAttributes(const System::SharedPtr<ExtendedAttributeCollection>& value);
    /// <summary>
    /// Gets the instance of <see cref="TimephasedDataCollection "></see> class containing elements of <see cref="TimephasedData"></see> class.
    /// </summary>
    ASPOSE_TASKS_SHARED_API System::SharedPtr<TimephasedDataCollection> get_TimephasedData();
    /// <summary>
    /// Sets the instance of <see cref="TimephasedDataCollection "></see> class containing elements of <see cref="TimephasedData"></see> class.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_TimephasedData(const System::SharedPtr<TimephasedDataCollection>& value);
    
    /// <summary>
    /// Returns the value to which the property is mapped in this container.
    /// </summary>
    /// <param name="key">the specified property key. <see cref="Asn"></see> for getting the property key.</param>
    /// <typeparam name="T">the type of the mapped value.</typeparam>
    /// <returns>the value to which the property is mapped in this container.</returns>
    template<typename T>
    T Get(const Key<T, AsnKey>& key) const
    {
        if (key.get_KeyType() == Aspose::Tasks::AsnKey::Task)
        {
            return System::ExplicitCast<T>(System::ExplicitCast<System::Object>(this->get_Task()));
        }
        
        if (key.get_KeyType() == Aspose::Tasks::AsnKey::Resource)
        {
            return System::ExplicitCast<T>(System::ExplicitCast<System::Object>(this->get_Resource()));
        }
        System::SharedPtr<System::Object> res;
        if (this->GetCalculatedValue(key.get_KeyType(), res))
        {
            return System::ExplicitCast<T>(res);
        }
        
        return this->container->template CheckPropAndGet<T>(key);
    }
    
    /// <summary>
    /// Maps the specified property to the specified value in this container.
    /// </summary>
    /// <param name="key">the specified property key. <see cref="Asn"></see> for getting the property key.</param>
    /// <param name="val">the value.</param>
    /// <typeparam name="T">the type of the mapped value.</typeparam>
    template<typename T>
    void Set(const Key<T, AsnKey>& key, const T& val)
    {
        
        if (key.get_KeyType() == Aspose::Tasks::AsnKey::Task)
        {
            this->set_Task(System::ExplicitCast<Aspose::Tasks::Task>(System::ExplicitCast<System::Object>(val)));
        }
        
        if (key.get_KeyType() == Aspose::Tasks::AsnKey::Resource)
        {
            this->set_Resource(System::ExplicitCast<Aspose::Tasks::Resource>(System::ExplicitCast<System::Object>(val)));
        }
        
        // Please do not remove this assignment due to C++ porting issues
        auto castVal = System::ExplicitCast<System::Object>(val);
        if (this->SetCalculatedValue(key.get_KeyType(), castVal))
        {
            return;
        }
        
        this->container->template CheckPropAndSet<T>(key, val);
        
        if (key.get_KeyType() == Aspose::Tasks::AsnKey::WorkContour)
        {
            this->set_IsWorkContourChanged(true);
        }
    }
    
    /// <summary>
    /// Deletes resource assignment from project assignments collection.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void Delete();
    /// <summary>
    /// Returns a value indicating whether this instance is equal to a specified instance of the <see cref="ResourceAssignment"></see> class.
    /// </summary>
    /// <param name="other">The specified instance of the <see cref="ResourceAssignment"></see> class to compare with this instance.</param>
    /// <returns><b>True</b> if the specified instance of the <see cref="ResourceAssignment"></see> class has the same UID value as this instance; otherwise, <b>false</b>.</returns>
    ASPOSE_TASKS_SHARED_API bool Equals(System::SharedPtr<ResourceAssignment> other) override;
    /// <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 ResourceAssignment that assign the same resource and task as this instance; otherwise, <b>false</b>.</returns>
    ASPOSE_TASKS_SHARED_API bool Equals(System::SharedPtr<System::Object> obj) override;
    /// <summary>
    /// Returns short string representation of the instance of the <see cref="ResourceAssignment"></see> class.
    /// The exact details of the representation are unspecified and subject to change.
    /// </summary>
    /// <returns>short string which represents assignment object.</returns>
    ASPOSE_TASKS_SHARED_API System::String ToString() const override;
    /// <summary>
    /// Returns a hash code value for the instance of the <see cref="ResourceAssignment"></see> class.
    /// </summary>
    /// <returns>returns a hash code value for this object.</returns>
    ASPOSE_TASKS_SHARED_API int32_t GetHashCode() const override;
    /// <summary>
    /// Generates list of time phased data based on the task duration and the scheduled start date.
    /// </summary>
    /// <param name="calendar">The calendar to generate time phased data from.</param>
    ASPOSE_TASKS_SHARED_API void TimephasedDataFromTaskDuration(const System::SharedPtr<Calendar>& calendar);
    /// <summary>
    /// Generates a list of time phased data.
    /// </summary>
    /// <param name="start">The specified start date.</param>
    /// <param name="time">The specified working time.</param>
    /// <param name="calendar">The specified working calendar.</param>
    /// <param name="list">The list of time phased data.</param>
    /// <param name="isWorking">The specified flag which specifies whether time-phased data is working or not.</param>
    /// <param name="type">The specified time-phased data type.</param>
    /// <returns>A maximum date from list or start date if list is empty.</returns>
    ASPOSE_TASKS_SHARED_API System::DateTime MakeTPs(System::DateTime start, System::TimeSpan time, const System::SharedPtr<Calendar>& calendar, const System::SharedPtr<System::Collections::Generic::List<System::SharedPtr<Aspose::Tasks::TimephasedData>>>& list, bool isWorking, int32_t type);
    /// <summary>
    /// Splits task into two parts.
    /// </summary>
    /// <param name="start">The beginning of work interruption to split based on.</param>
    /// <param name="finish">The end of work interruption to split based on.</param>
    /// <param name="calendar">The calendar to split based on.</param>
    /// <exception cref="ArgumentOutOfRangeException">Throws when start date is less than the assignment start date.</exception>
    /// <exception cref="ArgumentOutOfRangeException">Throws when finish date is greater than the assignment finish date.</exception>
    ASPOSE_TASKS_SHARED_API void SplitTask(System::DateTime start, System::DateTime finish, const System::SharedPtr<Calendar>& calendar);
    /// <summary>
    ///  Returns the instance <see cref="TimephasedDataCollection"></see> class containing instances of <see cref="TimephasedData"></see> class within given start and end dates of specified <see cref="TimephasedDataType"></see>.
    /// </summary>
    /// <param name="start">The start date for the time phased data.</param>
    /// <param name="end">The end date for the time phased data.</param>
    /// <param name="timephasedType">The type of time phased data (<see cref="Aspose::Tasks::TimephasedDataType"></see>).</param>
    /// <returns>returns a list which contains instances of <see cref="Aspose::Tasks::TimephasedData"></see> class.</returns>
    ASPOSE_TASKS_SHARED_API System::SharedPtr<TimephasedDataCollection> GetTimephasedData(System::DateTime start, System::DateTime end, TimephasedDataType timephasedType);
    /// <summary>
    /// Returns <see cref="TimephasedDataCollection"></see> object with the instances of <see cref="TimephasedData"></see> class within given start and end dates of <see cref="TimephasedDataType::AssignmentWork"></see>.
    /// </summary>
    /// <param name="start">The start date for the time phased data.</param>
    /// <param name="end">The end date for the time phased data.</param>
    /// <returns>returns a list containing instances of <see cref="Aspose::Tasks::TimephasedData"></see> class.</returns>
    ASPOSE_TASKS_SHARED_API System::SharedPtr<TimephasedDataCollection> GetTimephasedData(System::DateTime start, System::DateTime end);
    /// <summary>
    /// Gets amount of timephased work for the specified date time interval.
    /// </summary>
    /// <param name="start">Start of the date time interval.</param>
    /// <param name="end">End of the date time interval.</param>
    /// <param name="timephasedDataType">Type of the timephased data to use.</param>
    /// <returns></returns>
    ASPOSE_TASKS_SHARED_API System::TimeSpan GetTimephasedWork(System::DateTime start, System::DateTime end, TimephasedDataType timephasedDataType);
    /// <summary>
    /// Gets amount of timephased work for the specified date time interval.
    /// </summary>
    /// <param name="start">Start of the date time interval.</param>
    /// <param name="end">End of the date time interval.</param>
    /// <returns></returns>
    ASPOSE_TASKS_SHARED_API System::TimeSpan GetTimephasedWork(System::DateTime start, System::DateTime end);
    /// <summary>
    /// Sets units for assignment of a material resource with variable material consumption.
    /// The variable material consumption means that as the assignment duration changes, the quantity of materials used changes proportionally.
    /// </summary>
    /// <param name="units">Number of units accrued at the time period.</param>
    /// <param name="rateScaleType">Time period at which the unit value is accrued.</param>
    /// <remarks>For example, to set '123/month', SetUnitsScaled(123D, RateScaleType.Month) should be called.</remarks>
    /// <exception cref="InvalidOperationException">If the method is called for assignment of non-material resource.</exception>
    ASPOSE_TASKS_SHARED_API void SetMaterialResourceUnits(double units, RateScaleType rateScaleType);
    
protected:
 
    /// <summary>
    /// Gets parent project for this assignment.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_ParentProject(const System::SharedPtr<Project>& value);
    /// <summary>
    /// Gets AssignmentBaselineCollection object.
    /// The collection of baseline values associated with an assignment.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_Baselines(const System::SharedPtr<AssignmentBaselineCollection>& value);
    ASPOSE_TASKS_SHARED_API int32_t get_ExtendedAttributesCount();
    ASPOSE_TASKS_SHARED_API int32_t get_BaselineCount();
    ASPOSE_TASKS_SHARED_API bool get_IsShared() const;
    ASPOSE_TASKS_SHARED_API void set_IsShared(bool value);
    ASPOSE_TASKS_SHARED_API bool get_IsWork();
    ASPOSE_TASKS_SHARED_API bool get_IsFlatContour();
    ASPOSE_TASKS_SHARED_API bool get_IsMaterial();
    ASPOSE_TASKS_SHARED_API bool get_IsCost();
    ASPOSE_TASKS_SHARED_API System::Guid get_TempGuid() const;
    ASPOSE_TASKS_SHARED_API void set_TempGuid(System::Guid value);
    ASPOSE_TASKS_SHARED_API System::SharedPtr<Calendar> get_AssignmentCalendar();
    ASPOSE_TASKS_SHARED_API void set_AssignmentCalendar(const System::SharedPtr<Calendar>& value);
    ASPOSE_TASKS_SHARED_API bool get_IsValid();
    ASPOSE_TASKS_SHARED_API bool get_IsValidWork();
    ASPOSE_TASKS_SHARED_API bool get_IsSharedWork();
    /// <summary>
    /// Gets the assignment split parts.
    /// </summary>
    ASPOSE_TASKS_SHARED_API System::SharedPtr<SplitPartCollection> get_SplitParts();
    /// <summary>
    /// Sets the assignment split parts.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_SplitParts(const System::SharedPtr<SplitPartCollection>& value);
    ASPOSE_TASKS_SHARED_API System::SharedPtr<Rate> get_CurrentRate();
    ASPOSE_TASKS_SHARED_API void set_CurrentRate(const System::SharedPtr<Rate>& value);
    ASPOSE_TASKS_SHARED_API const System::ArrayPtr<uint8_t>& get_WorkCompleteRawTD() const;
    ASPOSE_TASKS_SHARED_API const System::ArrayPtr<uint8_t>& get_WorkIncompleteRawTD() const;
    ASPOSE_TASKS_SHARED_API const System::ArrayPtr<uint8_t>& get_WorkOverallocatedRawTD() const;
    ASPOSE_TASKS_SHARED_API const System::ArrayPtr<uint8_t>& get_WorkingExceptionsRaw() const;
    ASPOSE_TASKS_SHARED_API System::SharedPtr<TimeScaledParentWorkUnit> get_ScaledWorkComplete() const;
    ASPOSE_TASKS_SHARED_API void set_ScaledWorkComplete(const System::SharedPtr<TimeScaledParentWorkUnit>& value);
    ASPOSE_TASKS_SHARED_API System::SharedPtr<TimeScaledParentWorkUnit> get_ScaledWorkIncomplete() const;
    ASPOSE_TASKS_SHARED_API void set_ScaledWorkIncomplete(const System::SharedPtr<TimeScaledParentWorkUnit>& value);
    ASPOSE_TASKS_SHARED_API System::SharedPtr<TimeScaledParentWorkUnit> get_ScaledWorkOverallocated() const;
    ASPOSE_TASKS_SHARED_API const System::SharedPtr<Aspose::Tasks::TimeScaledExceptions>& get_TimeScaledExceptions() const;
    ASPOSE_TASKS_SHARED_API void set_TimeScaledExceptions(const System::SharedPtr<Aspose::Tasks::TimeScaledExceptions>& value);
    ASPOSE_TASKS_SHARED_API double get_PlannedValueNoCostUse() const;
    ASPOSE_TASKS_SHARED_API void set_PlannedValueNoCostUse(double value);
    ASPOSE_TASKS_SHARED_API bool get_IsCompleted();
    ASPOSE_TASKS_SHARED_API System::SharedPtr<Calendar> get_ResourceCalendar();
    ASPOSE_TASKS_SHARED_API bool get_IsTimephasedDataInitialized();
    ASPOSE_TASKS_SHARED_API bool get_IsWorkContourChanged() const;
    ASPOSE_TASKS_SHARED_API void set_IsWorkContourChanged(bool value);
    
    /// <summary>
    /// Initializes a new instance of the <see cref="ResourceAssignment"></see> class.
    /// </summary>
    ASPOSE_TASKS_SHARED_API ResourceAssignment(const System::SharedPtr<Project>& project);
    
    ASPOSE_TASKS_SHARED_API MEMBER_FUNCTION_MAKE_OBJECT_DECLARATION(ResourceAssignment, CODEPORTING_ARGS(const System::SharedPtr<Project>& project));
    
    /// <summary>
    /// Initializes a new instance of the <see cref="ResourceAssignment"></see> class.
    /// </summary>
    /// <param name="project">project</param>
    /// <param name="resource">resource</param>
    ASPOSE_TASKS_SHARED_API ResourceAssignment(const System::SharedPtr<Project>& project, const System::SharedPtr<Aspose::Tasks::Resource>& resource);
    
    ASPOSE_TASKS_SHARED_API MEMBER_FUNCTION_MAKE_OBJECT_DECLARATION(ResourceAssignment, CODEPORTING_ARGS(const System::SharedPtr<Project>& project, const System::SharedPtr<Aspose::Tasks::Resource>& resource));
    
    /// <summary>
    /// Initializes a new instance of the <see cref="ResourceAssignment"></see> class.
    /// </summary>
    /// <param name="task">task</param>
    /// <param name="resource">resource</param>
    ASPOSE_TASKS_SHARED_API ResourceAssignment(const System::SharedPtr<Aspose::Tasks::Task>& task, const System::SharedPtr<Aspose::Tasks::Resource>& resource);
    
    ASPOSE_TASKS_SHARED_API MEMBER_FUNCTION_MAKE_OBJECT_DECLARATION(ResourceAssignment, CODEPORTING_ARGS(const System::SharedPtr<Aspose::Tasks::Task>& task, const System::SharedPtr<Aspose::Tasks::Resource>& resource));
    
    /// <summary>
    /// Initializes a new instance of the <see cref="ResourceAssignment"></see> class.
    /// </summary>
    ASPOSE_TASKS_SHARED_API ResourceAssignment();
    
    ASPOSE_TASKS_SHARED_API MEMBER_FUNCTION_MAKE_OBJECT_DECLARATION(ResourceAssignment, CODEPORTING_ARGS());
    
    template<typename T>
    void SetDirectly(Key<T, AsnKey> key, T val)
    {
        this->container->template CheckPropAndSet<T>(key, val);
    }
    
    ASPOSE_TASKS_SHARED_API void SetMppTimephasedRawData(const System::ArrayPtr<uint8_t>& completeWorkRaw, const System::ArrayPtr<uint8_t>& remainingWorkRaw, const System::ArrayPtr<uint8_t>& overallocatedWorkRaw, const System::ArrayPtr<uint8_t>& workingExceptionRaw, const System::SharedPtr<TimeScaledParentWorkUnit>& scaledCompleteWork, const System::SharedPtr<TimeScaledParentWorkUnit>& scaledRemainingWork, const System::SharedPtr<TimeScaledParentWorkUnit>& scaledOverallocatedWork, const System::SharedPtr<Aspose::Tasks::TimeScaledExceptions>& scaledWorkingExceptions);
    ASPOSE_TASKS_SHARED_API System::SharedPtr<TimephasedDataCollection> GetTimephasedData(bool addBaselineTDs);
    ASPOSE_TASKS_SHARED_API void ResetOnlyTimephasedData();
    ASPOSE_TASKS_SHARED_API void SetTimeScaledExceptionsChanged();
    ASPOSE_TASKS_SHARED_API void ResetTimephasedData();
    ASPOSE_TASKS_SHARED_API void SetWorkContourType(WorkContourType type);
    ASPOSE_TASKS_SHARED_API void SetTimephasedData(const System::SharedPtr<ResourceAssignmentTimephasedDataCollection>& list);
    /// <summary>
    ///  Gets or sets an actual SplitParts without any side effect.
    /// </summary>
    /// <remarks>
    /// Use this method in case you do not want to save calculated SplitParts (as <see cref="SplitParts"></see> property does), so they can be calculated further.
    /// </remarks>
    ASPOSE_TASKS_SHARED_API System::SharedPtr<SplitPartCollection> GetCalculatedSplitParts();
    ASPOSE_TASKS_SHARED_API System::DateTime GetStartAddDelay(System::DateTime startDate);
    ASPOSE_TASKS_SHARED_API void SetStart();
    ASPOSE_TASKS_SHARED_API void SetFinish();
    ASPOSE_TASKS_SHARED_API System::String GetUnitsString();
    ASPOSE_TASKS_SHARED_API void SetCalendar(const System::SharedPtr<Project>& project);
    ASPOSE_TASKS_SHARED_API void MoveSplits(System::DateTime date);
    ASPOSE_TASKS_SHARED_API void CleanActualProperties();
    ASPOSE_TASKS_SHARED_API void SetBaseline(BaselineType baselineType);
    ASPOSE_TASKS_SHARED_API System::SharedPtr<System::Collections::Generic::List<System::SharedPtr<Aspose::Tasks::TimephasedData>>> GetSortedTimephasedData();
    ASPOSE_TASKS_SHARED_API Util::DateTimeInterval GetStartFinishOfTimephasedData();
    ASPOSE_TASKS_SHARED_API void GetCalendars(System::SharedPtr<Calendar>& taskCal, System::SharedPtr<Calendar>& rscCal);
    ASPOSE_TASKS_SHARED_API void AddAssignments();
    ASPOSE_TASKS_SHARED_API void CalculateTimephasedData(const System::SharedPtr<TimephasedDataCollection>& list, bool addBaselineTimephased);
    ASPOSE_TASKS_SHARED_API void RecalculateTimephasedData();
    ASPOSE_TASKS_SHARED_API Duration GetContouredRemainingWork();
    ASPOSE_TASKS_SHARED_API bool GetCalculatedValue(AsnKey key, System::SharedPtr<System::Object>& res) const;
    ASPOSE_TASKS_SHARED_API System::SharedPtr<TimeScaledParentWorkUnit> InferScaledWorkComplete();
    ASPOSE_TASKS_SHARED_API System::SharedPtr<TimeScaledParentWorkUnit> InferScaledWorkActual();
    ASPOSE_TASKS_SHARED_API System::SharedPtr<TimeScaledParentWorkUnit> InferScaledWorkRemaining();
    ASPOSE_TASKS_SHARED_API System::SharedPtr<TimeScaledParentWorkUnit> InferScaledWork(TimephasedDataType timephasedDataType);
    ASPOSE_TASKS_SHARED_API System::SharedPtr<TimeScaledParentWorkUnit> InferScaledWork(Util::ConditionDelegate<System::SharedPtr<Aspose::Tasks::TimephasedData>> timephasedDataCondition);
    ASPOSE_TASKS_SHARED_API void SetSplitsFinish(System::DateTime finish);
    ASPOSE_TASKS_SHARED_API Duration GetWork();
    ASPOSE_TASKS_SHARED_API double GetMeanLoad();
    ASPOSE_TASKS_SHARED_API System::SharedPtr<TimeScaledWorkUnit> GetMeanUnit();
    ASPOSE_TASKS_SHARED_API void AddImplicitWorkingTimeException(System::DateTime date, const System::SharedPtr<WorkingTimeCollection>& workingTimes);
    ASPOSE_TASKS_SHARED_API void AddImplicitWorkingTimeExceptionInterval(System::DateTime start, System::DateTime finish);
    ASPOSE_TASKS_SHARED_API void RemoveImplicitWorkingTimeException(System::DateTime date);
    ASPOSE_TASKS_SHARED_API System::SharedPtr<TimeScaledParentWorkUnit> GetScaledActualWork();
    ASPOSE_TASKS_SHARED_API System::SharedPtr<TimeScaledParentWorkUnit> GetScaledRemainingWork();
    ASPOSE_TASKS_SHARED_API System::SharedPtr<Calculations::IWorkContourIterator> GetActualWorkIterator();
    ASPOSE_TASKS_SHARED_API System::SharedPtr<Calculations::IWorkContourIterator> GetRemainingWorkIterator();
    ASPOSE_TASKS_SHARED_API System::SharedPtr<Calculations::IWorkContourIterator> GetWorkIterator();
    ASPOSE_TASKS_SHARED_API bool SetCalculatedValue(AsnKey keyType, const System::SharedPtr<System::Object>& v);
    
    ASPOSE_TASKS_SHARED_API virtual ~ResourceAssignment();
    
    #ifdef ASPOSE_GET_SHARED_MEMBERS
    ASPOSE_TASKS_SHARED_API void GetSharedMembers(System::Object::shared_members_type& result) const override;
    #endif
    
    
private:
 
    System::SharedPtr<PropertyContainer<AsnKey>> container;
    System::SharedPtr<TimephasedDataCollection> timephasedData;
    System::SharedPtr<Calendar> assignmentCalendar;
    System::SharedPtr<SplitPartCollection> splitParts;
    System::SharedPtr<Rate> currentRate;
    System::SharedPtr<AssignmentBaselineCollection> baselines;
    System::SharedPtr<ExtendedAttributeCollection> extendedAttributes;
    System::SharedPtr<TimeScaledParentWorkUnit> scaledWorkComplete;
    System::SharedPtr<TimeScaledParentWorkUnit> scaledWorkIncomplete;
    System::SharedPtr<TimeScaledParentWorkUnit> scaledWorkOverallocated;
    System::WeakPtr<Aspose::Tasks::Task> pr_Task;
    System::WeakPtr<Aspose::Tasks::Resource> pr_Resource;
    System::Nullable<System::Guid> pr_Guid;
    System::WeakPtr<Project> pr_ParentProject;
    
    bool get_HasChildren() override;
    System::SharedPtr<System::Collections::Generic::IEnumerable<System::SharedPtr<IExtendedAttributeParent>>> get_Items() override;
    
    bool pr_IsShared;
    System::Guid pr_TempGuid;
    System::ArrayPtr<uint8_t> pr_WorkCompleteRawTD;
    
    ASPOSE_TASKS_SHARED_API void set_WorkCompleteRawTD(const System::ArrayPtr<uint8_t>& value);
    
    System::ArrayPtr<uint8_t> pr_WorkIncompleteRawTD;
    
    ASPOSE_TASKS_SHARED_API void set_WorkIncompleteRawTD(const System::ArrayPtr<uint8_t>& value);
    
    System::ArrayPtr<uint8_t> pr_WorkOverallocatedRawTD;
    
    ASPOSE_TASKS_SHARED_API void set_WorkOverallocatedRawTD(const System::ArrayPtr<uint8_t>& value);
    
    System::ArrayPtr<uint8_t> pr_WorkingExceptionsRaw;
    
    ASPOSE_TASKS_SHARED_API void set_WorkingExceptionsRaw(const System::ArrayPtr<uint8_t>& value);
    ASPOSE_TASKS_SHARED_API void set_ScaledWorkOverallocated(const System::SharedPtr<TimeScaledParentWorkUnit>& value);
    
    System::SharedPtr<Aspose::Tasks::TimeScaledExceptions> pr_TimeScaledExceptions;
    double pr_PlannedValueNoCostUse;
    bool pr_IsWorkContourChanged;
    
    System::String get_DebuggerDisplay();
    
    System::SharedPtr<Calendar> GetCalendar() override;
    static bool IsGeneratedTimephasedType(TimephasedDataType timephasedType);
    bool HasMppTimephased();
    System::SharedPtr<TimeScaledParentWorkUnit> InferScaledWork(const System::SharedPtr<System::Collections::Generic::IList<System::SharedPtr<Aspose::Tasks::TimephasedData>>>& tds);
    System::SharedPtr<Calendar> TryToInheritCalendarFromTask();
    System::SharedPtr<Calendar> TryToInheritCalendarFromResource(const System::SharedPtr<Project>& project);
    void MakeTimephasedDataFromMpp(const System::SharedPtr<TimephasedDataCollection>& td);
    void MakeTimephasedDataFromXml(const System::SharedPtr<TimephasedDataCollection>& td);
    void AddBaselineTimephasedData(const System::SharedPtr<TimephasedDataCollection>& td);
    void UpdateWorkTD(const System::SharedPtr<System::Collections::Generic::IEnumerable<System::SharedPtr<Aspose::Tasks::TimephasedData>>>& complete, const System::SharedPtr<System::Collections::Generic::IEnumerable<System::SharedPtr<Aspose::Tasks::TimephasedData>>>& overtimeComplete);
    System::SharedPtr<SplitPartCollection> CalculateSplitParts();
    System::SharedPtr<System::Collections::Generic::IList<System::SharedPtr<Aspose::Tasks::TimephasedData>>> GenerateTimephased(System::DateTime start, System::DateTime end, TimephasedDataType timephasedType);
    Duration GetRemainingWork();
    Duration GetActualWork();
    // used in mpp files
    void GenerateTimephasedFromTimeScaledData(System::DateTime start, System::DateTime end, TimephasedDataType timephasedType, const System::SharedPtr<System::Collections::Generic::List<System::SharedPtr<Aspose::Tasks::TimephasedData>>>& outputList);
    System::SharedPtr<System::Collections::Generic::List<System::SharedPtr<Aspose::Tasks::TimephasedData>>> FilterTimephasedData(const System::SharedPtr<TimephasedDataCollection>& timephasedData, System::DateTime startDate, System::DateTime endDate, TimephasedDataType type);
    void SetBaselineValues(const System::SharedPtr<AssignmentBaseline>& bl);
    void SetBaselineTimephased(const System::SharedPtr<AssignmentBaseline>& bl);
    void TimephasedDataChanged(const System::SharedPtr<System::Object>& sender, const System::SharedPtr<System::EventArgs>& e);
    System::SharedPtr<Calendar> WrapCalendarIfNecessary(const System::SharedPtr<Calendar>& calendar);
    
};
 
} // namespace Tasks
} // namespace Aspose