TaskLink.h

#pragma once
//-----------------------------------------------------------------------
// <copyright file="TaskLink.cs" company="Aspose Pty Ltd">
//   Copyright (c) 2002-2024 Aspose Pty Ltd. All Rights Reserved.
// </copyright>
//-----------------------------------------------------------------------

#include <system/string.h>
#include <system/iequatable.h>
#include <system/guid.h>
#include <cstdint>

#include "aspose.tasks.cpp/NullableBool.h"
#include "aspose.tasks.cpp/aspose_tasks_api_defs.h"

namespace Aspose
{
namespace Tasks
{
namespace Calculations
{
class TaskSlackCalculator;
} // namespace Calculations
namespace Connectivity
{
class MpdTaskLinkMapper;
class MspTaskLinksMapper;
class PmTaskRelationMapper;
} // namespace Connectivity
namespace IO
{
namespace Html
{
class HtmlTaskTableReader;
} // namespace Html
namespace Mpx
{
class MpxReader;
} // namespace Mpx
namespace MSProject
{
class MPP12Reader;
class MPP14Reader;
class MPP9Reader;
class MPPTaskLinksReader;
} // namespace MSProject
namespace PrimaveraXml
{
class PrimaveraRelationshipNodeReader;
} // namespace PrimaveraXml
namespace Pwa
{
namespace InternalApi
{
namespace Mapping
{
class TaskLinkEntityMapper;
class TaskLinkToRawValuesMapper;
} // namespace Mapping
} // namespace InternalApi
} // namespace Pwa
namespace Xer
{
class XerRelationReader;
} // namespace Xer
namespace Xml
{
class TaskLinksNodeReader;
class TaskLinksNodeWriter;
} // namespace Xml
} // namespace IO
namespace Saving
{
class PrimaveraRelationshipNodeWriter;
class XerRelationTable;
} // namespace Saving
namespace Scheduling
{
class ConstraintSolver;
class TopologicalSort;
class TopsortCriticalPath;
} // namespace Scheduling
class Task;
class TaskLinkCollection;
enum class TaskLinkType;
class TaskWarningCalculator;
enum class TimeUnitType : int8_t;
namespace Visualization
{
class ApsFFVerticalLinkBuilder;
class ApsFSVerticalLinkBuilder;
class ApsLinksBuilder;
class ApsSFVerticalLinkBuilder;
class ApsSSVerticalLinkBuilder;
class TaskToColumnText;
} // namespace Visualization
} // namespace Tasks
} // namespace Aspose
namespace System
{
namespace Collections
{
namespace Generic
{
template <typename> class Stack;
} // namespace Generic
} // namespace Collections
class TimeSpan;
} // namespace System

namespace Aspose {

namespace Tasks {

/// <summary>
/// Represents a predecessor link.
/// </summary>
class ASPOSE_TASKS_SHARED_CLASS TaskLink final : public System::IEquatable<System::SharedPtr<Aspose::Tasks::TaskLink>>
{
    typedef TaskLink ThisType;
    typedef System::IEquatable<System::SharedPtr<Aspose::Tasks::TaskLink>> BaseType;
    
    typedef ::System::BaseTypesInfo<BaseType> ThisTypeBaseTypesInfo;
    ASPOSE_TASKS_SHARED_RTTI_INFO_DECL();
    
    friend class Aspose::Tasks::Calculations::TaskSlackCalculator;
    friend class Aspose::Tasks::IO::PrimaveraXml::PrimaveraRelationshipNodeReader;
    friend class Aspose::Tasks::Task;
    friend class Aspose::Tasks::IO::Pwa::InternalApi::Mapping::TaskLinkToRawValuesMapper;
    friend class Aspose::Tasks::Connectivity::MpdTaskLinkMapper;
    friend class Aspose::Tasks::Connectivity::MspTaskLinksMapper;
    friend class Aspose::Tasks::Connectivity::PmTaskRelationMapper;
    friend class Aspose::Tasks::IO::Html::HtmlTaskTableReader;
    friend class Aspose::Tasks::IO::MSProject::MPP12Reader;
    friend class Aspose::Tasks::IO::MSProject::MPP14Reader;
    friend class Aspose::Tasks::IO::MSProject::MPPTaskLinksReader;
    friend class Aspose::Tasks::IO::MSProject::MPP9Reader;
    friend class Aspose::Tasks::IO::Mpx::MpxReader;
    friend class Aspose::Tasks::IO::Xer::XerRelationReader;
    friend class Aspose::Tasks::IO::Pwa::InternalApi::Mapping::TaskLinkEntityMapper;
    friend class Aspose::Tasks::IO::Xml::TaskLinksNodeReader;
    friend class Aspose::Tasks::IO::Xml::TaskLinksNodeWriter;
    friend class Aspose::Tasks::TaskWarningCalculator;
    friend class Aspose::Tasks::Saving::XerRelationTable;
    friend class Aspose::Tasks::Saving::PrimaveraRelationshipNodeWriter;
    friend class Aspose::Tasks::Scheduling::ConstraintSolver;
    friend class Aspose::Tasks::Scheduling::TopsortCriticalPath;
    friend class Aspose::Tasks::Scheduling::TopologicalSort;
    friend class Aspose::Tasks::TaskLinkCollection;
    friend class Aspose::Tasks::Visualization::ApsFFVerticalLinkBuilder;
    friend class Aspose::Tasks::Visualization::ApsLinksBuilder;
    friend class Aspose::Tasks::Visualization::ApsFSVerticalLinkBuilder;
    friend class Aspose::Tasks::Visualization::ApsSFVerticalLinkBuilder;
    friend class Aspose::Tasks::Visualization::ApsSSVerticalLinkBuilder;
    friend class Aspose::Tasks::Visualization::TaskToColumnText;
    
public:

    /// <summary>
    /// Gets a value indicating whether a predecessor is part of another project.
    /// </summary>
    ASPOSE_TASKS_SHARED_API bool get_IsCrossProject() const;
    /// <summary>
    /// Sets a value indicating whether a predecessor is part of another project.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_IsCrossProject(bool value);
    /// <summary>
    /// Gets the external predecessor project.
    /// </summary>
    ASPOSE_TASKS_SHARED_API System::String get_CrossProjectName() const;
    /// <summary>
    /// Sets the external predecessor project.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_CrossProjectName(const System::String& value);
    /// <summary>
    /// Gets the lag in tenths of a minute or percentage.
    /// </summary>
    ASPOSE_TASKS_SHARED_API int32_t get_LinkLag() const;
    /// <summary>
    /// Sets the lag in tenths of a minute or percentage.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_LinkLag(int32_t value);
    /// <summary>
    /// Gets lag duration, depending on LagFormat.
    /// </summary>
    /// <remarks>Link lag can be a percentage value (LagFormat is TimeUnitType.Percent).
    /// In this case the duration is calculated as a percentage of PredTask's duration.
    /// Otherwise the method returns TimeSpan value representing TaskLink's lag.</remarks>
    /// <exception cref="ArgumentException">When trying to set the value for TaskLinks where LagFormat is TimeUnitType.Percent.</exception>
    ASPOSE_TASKS_SHARED_API System::TimeSpan get_LinkLagTimeSpan();
    /// <summary>
    /// Sets lag duration, depending on LagFormat.
    /// </summary>
    /// <remarks>Link lag can be a percentage value (LagFormat is TimeUnitType.Percent).
    /// In this case the duration is calculated as a percentage of PredTask's duration.
    /// Otherwise the method returns TimeSpan value representing TaskLink's lag.</remarks>
    /// <exception cref="ArgumentException">When trying to set the value for TaskLinks where LagFormat is TimeUnitType.Percent.</exception>
    ASPOSE_TASKS_SHARED_API void set_LinkLagTimeSpan(System::TimeSpan value);
    /// <summary>
    /// Gets the format for expressing the lag format.
    /// </summary>
    ASPOSE_TASKS_SHARED_API TimeUnitType get_LagFormat() const;
    /// <summary>
    /// Sets the format for expressing the lag format.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_LagFormat(TimeUnitType value);
    /// <summary>
    /// Gets the predecessor task.
    /// </summary>
    ASPOSE_TASKS_SHARED_API const System::SharedPtr<Task>& get_PredTask() const;
    /// <summary>
    /// Sets the predecessor task.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_PredTask(const System::SharedPtr<Task>& value);
    /// <summary>
    /// Gets the successor task.
    /// </summary>
    ASPOSE_TASKS_SHARED_API const System::SharedPtr<Task>& get_SuccTask() const;
    /// <summary>
    /// Sets the successor task.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_SuccTask(const System::SharedPtr<Task>& value);
    /// <summary>
    /// Gets the type of a link.
    /// </summary>
    ASPOSE_TASKS_SHARED_API TaskLinkType get_LinkType() const;
    /// <summary>
    /// Sets the type of a link.
    /// </summary>
    ASPOSE_TASKS_SHARED_API void set_LinkType(TaskLinkType value);
    
    /// <summary>
    /// Returns a hash code value for the instance of the <see cref="TaskLink"></see> class.
    /// </summary>
    /// <returns>returns a hash code value for this object.</returns>
    ASPOSE_TASKS_SHARED_API int32_t GetHashCode() const override;
    /// <summary>
    /// Returns a value indicating whether this instance is equal to a specified object.
    /// </summary>
    /// <param name="other">The specified instance of the <see cref="TaskLink"></see> class to compare with this instance.</param>
    /// <returns><b>True</b> if the specified instance of the <see cref="TaskLink"></see> class has the same predecessor and successor tasks as this instance; otherwise, <b>false</b>.</returns>
    ASPOSE_TASKS_SHARED_API bool Equals(System::SharedPtr<TaskLink> other) override;
    /// <summary>
    /// Returns string representation of a TaskLink.
    /// The exact details of the representation are unspecified and subject to change.
    /// </summary>
    /// <returns>string which represents TaskLink object.</returns>
    ASPOSE_TASKS_SHARED_API System::String ToString() const 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 the specified object is a TaskLink that has the same predecessor and successor
    /// as this instance; otherwise, <b>false</b>.</returns>
    ASPOSE_TASKS_SHARED_API bool Equals(System::SharedPtr<System::Object> obj) override;
    
protected:

    ASPOSE_TASKS_SHARED_API NullableBool get_NullableCrossProject() const;
    ASPOSE_TASKS_SHARED_API void set_NullableCrossProject(NullableBool value);
    ASPOSE_TASKS_SHARED_API bool get_IsDummy() const;
    ASPOSE_TASKS_SHARED_API int32_t get_Uid() const;
    ASPOSE_TASKS_SHARED_API void set_Uid(int32_t value);
    ASPOSE_TASKS_SHARED_API System::Guid get_Guid() const;
    ASPOSE_TASKS_SHARED_API void set_Guid(System::Guid value);
    ASPOSE_TASKS_SHARED_API bool get_IsNegativeLag();
    ASPOSE_TASKS_SHARED_API bool get_PredecessorFinishLinked();
    
    /// <summary>
    /// Initializes a new instance of the <see cref="TaskLink"></see> class. 
    /// </summary>
    /// <param name="predTask">
    /// Predecessor task.
    /// </param>
    /// <param name="succTask">
    /// Successor task.
    /// </param>
    /// <param name="linkType">
    /// Type of the link.
    /// </param>
    ASPOSE_TASKS_SHARED_API TaskLink(const System::SharedPtr<Task>& predTask, const System::SharedPtr<Task>& succTask, TaskLinkType linkType);
    
    ASPOSE_TASKS_SHARED_API MEMBER_FUNCTION_MAKE_OBJECT_DECLARATION(TaskLink, CODEPORTING_ARGS(const System::SharedPtr<Task>& predTask, const System::SharedPtr<Task>& succTask, TaskLinkType linkType));
    
    ASPOSE_TASKS_SHARED_API TaskLink(const System::SharedPtr<Task>& predTask, const System::SharedPtr<Task>& succTask, TaskLinkType linkType, bool isDummy);
    
    ASPOSE_TASKS_SHARED_API MEMBER_FUNCTION_MAKE_OBJECT_DECLARATION(TaskLink, CODEPORTING_ARGS(const System::SharedPtr<Task>& predTask, const System::SharedPtr<Task>& succTask, TaskLinkType linkType, bool isDummy));
    ASPOSE_TASKS_SHARED_API void AddRelation();
    ASPOSE_TASKS_SHARED_API void RemoveRelation();
    ASPOSE_TASKS_SHARED_API System::TimeSpan GetLagDuration() const;
    ASPOSE_TASKS_SHARED_API System::String GetTaskLinkString(int32_t taskUid);
    
    virtual ASPOSE_TASKS_SHARED_API ~TaskLink();
    
    #ifdef ASPOSE_GET_SHARED_MEMBERS
    ASPOSE_TASKS_SHARED_API void GetSharedMembers(System::Object::shared_members_type& result) const override;
    #endif
    
    
private:

    System::Guid internalGuid;
    bool isDummy;
    TaskLinkType linkType;
    System::String pr_CrossProjectName;
    int32_t pr_LinkLag;
    TimeUnitType pr_LagFormat;
    System::WeakPtr<Task> pr_PredTask;
    System::WeakPtr<Task> pr_SuccTask;
    NullableBool pr_NullableCrossProject;
    int32_t pr_Uid;
    System::Guid pr_Guid;
    
    bool get_Invalid() const;
    
    System::String GetLagString() const;
    void CheckTwiceLinked();
    void CheckCircuits();
    void CheckCircuits(const System::SharedPtr<Task>& temp, const System::SharedPtr<System::Collections::Generic::Stack<System::SharedPtr<Task>>>& predecessors);
    void CheckLink();
    
};

} // namespace Tasks
} // namespace Aspose