TimephasedDataCollection.h

#pragma once
//-----------------------------------------------------------------------
// <copyright file="TimephasedDataCollection.cs" company="Aspose Pty Ltd">
//   Copyright (c) 2002-2024 Aspose Pty Ltd. All Rights Reserved.
// </copyright>
//-----------------------------------------------------------------------
 
#include <system/multicast_delegate.h>
#include <system/eventhandler.h>
#include <system/collections/ilist.h>
#include <system/collections/icomparer.h>
#include <system/array.h>
#include <cstdint>
 
#include "aspose.tasks.cpp/aspose_tasks_api_defs.h"
 
namespace Aspose
{
namespace Tasks
{
class BaselineTimephasedDataMaker;
namespace Calculations
{
class ResourceAssignmentRateByDateEnumerator;
class TimephasedDataCalculator;
class TimeScaledCalculator;
} // namespace Calculations
class Calendar;
namespace IO
{
namespace MSProject
{
class MPP9ResourceAssignmentReader;
class MPPResourceWriter;
class MppTimephasedDataWriter;
} // namespace MSProject
namespace Xml
{
class TimephasedDataNodeReader;
} // namespace Xml
} // namespace IO
class OptimizedForSearchingTimephasedDataCollection;
namespace Recalculation
{
class TaskSplitCalculator;
} // namespace Recalculation
class Resource;
class ResourceAssignment;
class ResourceAssignmentTimephasedDataCollection;
class ResourceTimephasedDataCollection;
class Task;
class TaskPlanner;
class TaskTimephasedDataCollection;
namespace Timephased
{
class CostInterval;
class WorkInterval;
} // namespace Timephased
class TimephasedData;
enum class TimephasedDataType : int8_t;
class TimephasedWorkCostSelector;
namespace Util
{
class BaselineHelper;
template <typename T> using ConditionDelegate = System::MulticastDelegate<bool(T)>;
} // namespace Util
} // namespace Tasks
} // namespace Aspose
namespace System
{
namespace Collections
{
namespace Generic
{
template <typename> class IEnumerable;
template <typename> class IEnumerator;
template <typename> class List;
} // namespace Generic
} // namespace Collections
class DateTime;
class TimeSpan;
} // namespace System
 
namespace Aspose {
 
namespace Tasks {
 
/// <summary>
/// Represents a collection of <see cref="TimephasedData"></see> objects.
/// </summary>
class ASPOSE_TASKS_SHARED_CLASS TimephasedDataCollection : public System::Collections::Generic::IList<System::SharedPtr<Aspose::Tasks::TimephasedData>>
{
    typedef TimephasedDataCollection ThisType;
    typedef System::Collections::Generic::IList<System::SharedPtr<Aspose::Tasks::TimephasedData>> BaseType;
    
    typedef ::System::BaseTypesInfo<BaseType> ThisTypeBaseTypesInfo;
    ASPOSE_TASKS_SHARED_RTTI_INFO_DECL();
    
    friend class Aspose::Tasks::Calculations::TimeScaledCalculator;
    friend class Aspose::Tasks::Calculations::ResourceAssignmentRateByDateEnumerator;
    friend class Aspose::Tasks::Calculations::TimephasedDataCalculator;
    friend class Aspose::Tasks::Resource;
    friend class Aspose::Tasks::ResourceAssignment;
    friend class Aspose::Tasks::Task;
    friend class Aspose::Tasks::BaselineTimephasedDataMaker;
    friend class Aspose::Tasks::Util::BaselineHelper;
    friend class Aspose::Tasks::IO::MSProject::MPP9ResourceAssignmentReader;
    friend class Aspose::Tasks::IO::MSProject::MPPResourceWriter;
    friend class Aspose::Tasks::IO::MSProject::MppTimephasedDataWriter;
    friend class Aspose::Tasks::IO::Xml::TimephasedDataNodeReader;
    friend class Aspose::Tasks::TaskPlanner;
    friend class Aspose::Tasks::Recalculation::TaskSplitCalculator;
    friend class Aspose::Tasks::ResourceAssignmentTimephasedDataCollection;
    friend class Aspose::Tasks::ResourceTimephasedDataCollection;
    friend class Aspose::Tasks::TaskTimephasedDataCollection;
    friend class Aspose::Tasks::TimephasedData;
    friend class Aspose::Tasks::TimephasedWorkCostSelector;
    
protected:
 
    class ASPOSE_TASKS_SHARED_CLASS TimephasedDataFinishDateAscComparer final : public System::Collections::Generic::IComparer<System::SharedPtr<Aspose::Tasks::TimephasedData>>
    {
        typedef TimephasedDataFinishDateAscComparer ThisType;
        typedef System::Collections::Generic::IComparer<System::SharedPtr<Aspose::Tasks::TimephasedData>> BaseType;
        
        typedef ::System::BaseTypesInfo<BaseType> ThisTypeBaseTypesInfo;
        ASPOSE_TASKS_SHARED_RTTI_INFO_DECL();
        
    private:
    
        /// <summary>
        /// Compares two time phased data units.
        /// </summary>
        /// <param name="x">Left time phased data unit.</param>
        /// <param name="y">Right time phased data unit.</param>
        /// <returns>1 if left is greater, -1 if it's less and 0 otherwise.</returns>
        int32_t Compare(const System::SharedPtr<TimephasedData>& x, const System::SharedPtr<TimephasedData>& y) const override;
        
    };
    
    
public:
 
    /// <summary>
    /// Gets the number of objects contained in this <see cref="TimephasedDataCollection"></see> object.
    /// </summary>
    ASPOSE_TASKS_SHARED_API int32_t get_Count() const override;
    /// <summary>Gets a value indicating whether the <see cref="System::Collections::Generic::ICollection{T}"></see> is read-only.</summary>
    /// <returns>true if the <see cref="System::Collections::Generic::ICollection{T}"></see> is read-only; otherwise, false.</returns>
    ASPOSE_TASKS_SHARED_API bool get_IsReadOnly() const override;
    
    /// <summary>Initializes a new instance of the <see cref="TimephasedDataCollection"></see> class.</summary>
    // ReSharper disable once UnusedMember.Global
    // ReSharper disable once PublicConstructorInAbstractClass
    ASPOSE_TASKS_SHARED_API TimephasedDataCollection();
    
    /// <summary>
    /// Returns the element at the specified index. The set accessor is not supported. 
    /// property to set timephased data.
    /// </summary>
    /// <param name="index">The zero-based index of the element to get.</param>
    /// <returns>the element at the specified index.</returns>
    ASPOSE_TASKS_SHARED_API System::SharedPtr<TimephasedData> idx_get(int32_t index) const override;
    /// <summary>
    /// Returns the element at the specified index. The set accessor is not supported. 
    /// property to set timephased data.
    /// </summary>
    /// <param name="index">The zero-based index of the element to get.</param>
    /// <param name="value">the element at the specified index.</param>
    ASPOSE_TASKS_SHARED_API void idx_set(int32_t index, System::SharedPtr<TimephasedData> value) override;
    
    /// <summary>
    /// Removes all items from the <see cref="TimephasedDataCollection"></see>.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void Clear() override;
    /// <summary>
    /// Determines whether the <see cref="TimephasedDataCollection"></see> contains a specific value.
    /// </summary>
    /// <returns>true if <paramref name="item" ></paramref> is found in the collection; otherwise, false.</returns>
    /// <param name="item">The object to locate in the collection.</param>
    ASPOSE_TASKS_SHARED_API bool Contains(const System::SharedPtr<TimephasedData>& item) const override;
    /// <summary>
    /// Adds <see cref="TimephasedData"></see> instance to this collection object.
    /// </summary>
    /// <param name="item">The item to add.</param>
    /// <exception cref="ArgumentNullException"> if parameter td is null. </exception>
    ASPOSE_TASKS_SHARED_API void Add(const System::SharedPtr<TimephasedData>& item) override;
    /// <summary>
    /// Adds a collection of <see cref="TimephasedData"></see> instances to this collection object.
    /// </summary>
    /// <param name="timephasedCollection">A collection of <see cref="TimephasedData"></see> objects to add.</param>
    ASPOSE_TASKS_SHARED_API void AddRange(const System::SharedPtr<System::Collections::Generic::IEnumerable<System::SharedPtr<TimephasedData>>>& timephasedCollection);
    /// <summary>
    /// Converts the <see cref="TimephasedDataCollection"></see> object to a list of <see cref="TimephasedData"></see> objects.
    /// </summary>
    /// <returns>List of <see cref="TimephasedData"></see> objects.</returns>
    ASPOSE_TASKS_SHARED_API System::SharedPtr<System::Collections::Generic::List<System::SharedPtr<TimephasedData>>> ToList();
    /// <summary>
    /// Copies the elements of the <see cref="TimephasedDataCollection"></see> to an <see cref="System::Array"></see>,
    /// starting at a particular <see cref="System::Array"></see> index.
    /// </summary>
    /// <param name="array">The one-dimensional <see cref="System::Array"></see> that is the destination of the elements copied from <see cref="TimephasedDataCollection"></see>.
    /// The <see cref="System::Array"></see> must have zero-based indexing.</param>
    /// <param name="arrayIndex">The zero-based index in <paramref name="array" ></paramref> at which copying begins.</param>
    /// <exception cref="System::ArgumentNullException">
    /// <paramref name="array" ></paramref> is null.</exception>
    /// <exception cref="System::ArgumentOutOfRangeException">
    /// <paramref name="arrayIndex" ></paramref> is less than 0.</exception>
    /// <exception cref="System::ArgumentException">The number of elements in the source <see cref="TimephasedDataCollection"></see>
    /// is greater than the available space from <paramref name="arrayIndex" ></paramref> to the end of the destination <paramref name="array" ></paramref>.
    /// </exception>
    ASPOSE_TASKS_SHARED_API void CopyTo(System::ArrayPtr<System::SharedPtr<TimephasedData>> array, int32_t arrayIndex) override;
    /// <summary>
    /// Removes <see cref="TimephasedData"></see> instance from this collection object.
    /// </summary>
    /// <param name="item">The item to remove.</param>
    /// <returns>
    /// true if <paramref name="item" ></paramref> was successfully removed from the <see cref="TimephasedDataCollection"></see>; otherwise, false.
    /// This method also returns false if <paramref name="item" ></paramref> is not found in the <see cref="TimephasedDataCollection"></see>.
    /// </returns>
    ASPOSE_TASKS_SHARED_API bool Remove(const System::SharedPtr<TimephasedData>& item) override;
    /// <summary>
    /// Returns an enumerator for this collection.
    /// </summary>
    /// <returns>an enumerator for this collection.</returns>
    ASPOSE_TASKS_SHARED_API System::SharedPtr<System::Collections::Generic::IEnumerator<System::SharedPtr<TimephasedData>>> GetEnumerator() override;
    /// <summary>
    /// Selects all time phases between <paramref name="startTime"></paramref> and <paramref name="finishTime"></paramref>. Has O(log n) complexity in average case.
    /// </summary>
    /// <param name="timephasedDataType">
    /// Type of time phases to select.
    /// </param>
    /// <param name="startTime">
    /// Interval's start.
    /// </param>
    /// <param name="finishTime">
    /// Interval's finish.
    /// </param>
    /// <returns> Returns new list instance of <see cref="TimephasedDataCollection"></see> data ordered by Start property. </returns>
    ASPOSE_TASKS_SHARED_API System::SharedPtr<System::Collections::Generic::IList<System::SharedPtr<TimephasedData>>> SelectBetweenStartAndFinish(TimephasedDataType timephasedDataType, System::DateTime startTime, System::DateTime finishTime);
    
protected:
 
    ASPOSE_TASKS_SHARED_API System::EventHandler<> get_Changed() const;
    ASPOSE_TASKS_SHARED_API void set_Changed(System::EventHandler<> value);
    
    ASPOSE_TASKS_SHARED_API TimephasedDataCollection(const System::SharedPtr<System::Collections::Generic::IList<System::SharedPtr<TimephasedData>>>& items);
    
    ASPOSE_TASKS_SHARED_API System::TimeSpan GetDayWork(const System::SharedPtr<Calendar>& calendar, TimephasedDataType timephasedDataType, System::DateTime date);
    ASPOSE_TASKS_SHARED_API Timephased::WorkInterval GetIntervalWork(const System::SharedPtr<Calendar>& calendar, TimephasedDataType timephasedDataType, System::DateTime startDate, System::DateTime finishDate);
    ASPOSE_TASKS_SHARED_API Timephased::CostInterval GetIntervalCost(const System::SharedPtr<Calendar>& calendar, TimephasedDataType timephasedDataType, System::DateTime startDate, System::DateTime finishDate);
    /// <summary>
    /// Adds <see cref="TimephasedData"></see> instance to this collection object.
    /// </summary>
    /// <param name="item">The item to add.</param>
    /// <exception cref="ArgumentNullException"> if parameter td is null. </exception>
    ASPOSE_TASKS_SHARED_API void AddInternal(const System::SharedPtr<TimephasedData>& item);
    /// <summary>
    /// Adds a collection of <see cref="TimephasedData"></see> instances to this collection object.
    /// </summary>
    /// <param name="timephasedCollection">A collection of <see cref="TimephasedData"></see> objects to add.</param>
    ASPOSE_TASKS_SHARED_API void AddRangeInternal(const System::SharedPtr<System::Collections::Generic::IEnumerable<System::SharedPtr<TimephasedData>>>& timephasedCollection);
    /// <summary>
    /// Adds a collection of <see cref="TimephasedData"></see> instances to this collection object.
    /// </summary>
    /// <param name="timephasedCollection">A collection of <see cref="TimephasedData"></see> objects to add.</param>
    ASPOSE_TASKS_SHARED_API void AddRangeInternal(const System::SharedPtr<TimephasedDataCollection>& timephasedCollection);
    ASPOSE_TASKS_SHARED_API int32_t GetSearchDictionaryCount();
    ASPOSE_TASKS_SHARED_API System::TimeSpan GetDuration();
    /// <summary>
    /// Adds <see cref="TimephasedData"></see> instance to this collection object.
    /// </summary>
    /// <param name="item">The item to add.</param>
    /// <param name="isCustomTd">A flag shows whether is custom timephased datum or not.</param>
    /// <exception cref="ArgumentNullException"> if parameter td is null. </exception>
    virtual ASPOSE_TASKS_SHARED_API void AddInternal(System::SharedPtr<TimephasedData> item, bool isCustomTd);
    virtual ASPOSE_TASKS_SHARED_API void InsertInternal(int32_t index, System::SharedPtr<TimephasedData> item);
    ASPOSE_TASKS_SHARED_API System::SharedPtr<System::Collections::Generic::IEnumerable<System::SharedPtr<TimephasedData>>> EnumerateByCondition(Util::ConditionDelegate<System::SharedPtr<TimephasedData>> condition);
    ASPOSE_TASKS_SHARED_API System::SharedPtr<System::Collections::Generic::List<System::SharedPtr<TimephasedData>>> GetByType(TimephasedDataType type);
    
    virtual ASPOSE_TASKS_SHARED_API ~TimephasedDataCollection();
    
    #ifdef ASPOSE_GET_SHARED_MEMBERS
    ASPOSE_TASKS_SHARED_API void GetSharedMembers(System::Object::shared_members_type& result) const override;
    #endif
    
    
private:
 
    System::SharedPtr<OptimizedForSearchingTimephasedDataCollection> timephasesOptimizedForSearchingByStartDate;
    System::SharedPtr<System::Collections::Generic::IList<System::SharedPtr<TimephasedData>>> items;
    System::EventHandler<> pr_Changed;
    
    int32_t IndexOf(const System::SharedPtr<TimephasedData>& item) const override;
    void Insert(int32_t index, const System::SharedPtr<TimephasedData>& item) override;
    void RemoveAt(int32_t index) override;
    /// <summary>
    /// Initializes the search-optimized collection of timephased data.
    /// </summary>
    /// <param name="list">The list of timephased items to optimize the searching for.</param>
    void InitializeSearch(const System::SharedPtr<System::Collections::Generic::IEnumerable<System::SharedPtr<TimephasedData>>>& list);
    /// <summary>
    /// Returns timephased data list.
    /// </summary>
    /// <returns>Return timephased data.</returns>
    /// <summary>
    /// Returns timephased data list.
    /// </summary>
    /// <returns>Return timephased data.</returns>
    System::SharedPtr<System::Collections::Generic::IList<System::SharedPtr<TimephasedData>>> GetTimephasedData() const;
    /// <summary>
    /// Adds a collection of <see cref="TimephasedData"></see> instances to this collection object.
    /// </summary>
    /// <param name="timephasedCollection">A collection of <see cref="TimephasedData"></see> objects to add.</param>
    /// <param name="collectionContainsCustomTds">A flag indicating whether collection contains custom time phase data (i.e. time phase data created by user, not AT).</param>
    void AddRangeInternal(const System::SharedPtr<System::Collections::Generic::IEnumerable<System::SharedPtr<TimephasedData>>>& timephasedCollection, bool collectionContainsCustomTds);
    void OnChange();
    
};
 
} // namespace Tasks
} // namespace Aspose