File indexing completed on 2024-05-12 04:20:39

 /*
  * SPDX-FileCopyrightText: 2001-2015 Klaralvdalens Datakonsult AB. All rights reserved.
  *
  * This file is part of the KGantt library.
  *
  * SPDX-License-Identifier: GPL-2.0-or-later
  */
 
 #ifndef KGANTTCONSTRAINT_H
 #define KGANTTCONSTRAINT_H
 
 #include <QMap>
 #include <QModelIndex>
 #include <QObject>
 #include <QSharedDataPointer>
 #include <QVariant>
 
 #include "kganttglobal.h"
 #ifndef QT_NO_DEBUG_STREAM
 #include <QDebug>
 #endif
 
 namespace KGantt {
 
 
     /*!\class KGantt::Constraint
      *\ingroup KGantt
      * \brief A class used to represent a dependency.
      *
      * Instances of this class represent a dependency between the
      * data items pointed to by a start-QModelIndex and an
      * end-QModelIndex.
      */
     class KGANTT_EXPORT Constraint {
         class Private;
     public:
         /*!\enum KGantt::Constraint::Type
          * This enum is unused for now.
          */
         enum Type
         {
             TypeSoft = 0,
             TypeHard = 1
         };
         enum RelationType
         {
             FinishStart = 0,
             FinishFinish = 1,
             StartStart = 2,
             StartFinish = 3
         };
 
         /*!\enum KGantt::Constraint::ConstraintDataRole
          * Data roles used when specifying the pen to draw constraints with.
          * \sa setData
          */
         enum ConstraintDataRole
         {
             ValidConstraintPen = Qt::UserRole,
             InvalidConstraintPen
         };
 
         typedef QMap<int, QVariant> DataMap;
 
         /*! Default constructor, created an invalid constraint. */
         Constraint();
 
         /*! Constructor. Creates a dependency for \a idx2 on \a idx1.
          * \param type controls if the constraint is a soft one that
          * is allowed to be broken (ie, go backwards in time) or a hard
          * constraint that will not allow the user to move an item so
          * that the constraint would have to go backwards. The default is
          * TypeSoft.
          *
          * Actually enforcing hard constraints is the responsibility of
          * the AbstractGrid subclass used in the view.
          *
          * \param relationType defines how the tasks depends on each other.
          * relationType can be FinishStart (default), FinishFinish, StartStart or StartFinish.
          */
         Constraint( const QModelIndex& idx1,
                     const QModelIndex& idx2,
                     Type type=TypeSoft,
                     RelationType relType=FinishStart,
                     const DataMap& datamap=DataMap() );
 
         /*! Copy-Constructor. */
         Constraint( const Constraint& other);
 
 
         /*! Destructor */
         ~Constraint();
 
         /*! This is unused for now. */
         Type type() const;
 
         /*! This is unused for now. */
         RelationType relationType() const;
 
         /*! \returns The dependency index */
         QModelIndex startIndex() const;
 
         /*! \returns The constrained index */
         QModelIndex endIndex() const;
 
         /*! Set data on this index for the specified role.
          * \param role The role to set the data for.
          * \param value The data to set on the index.
          * \sa ConstraintDataRole
          */
         void setData( int role, const QVariant& value );
 
         /*! \returns The data associated with this index for the specified role.
          * \param role The role to fetch the data for.
          * \sa ConstraintDataRole
          */
         QVariant data( int role ) const;
 
         /*! Set data on this constraint to the keys/values in \a datamap.
          * Clears any existing data from the constraint.
          */
         void setDataMap( const QMap< int, QVariant >& datamap );
 
         /*! \returns all the data set on this constraint. \see setDataMap
          */
         QMap< int, QVariant > dataMap() const;
 
         bool compareIndexes(const Constraint& other) const;
 
         /*! Assignment operator. */
         Constraint& operator=( const Constraint& other );
 
         /*! Compare two Constraint objects. Two Constraints are equal
          * if the have the same start and end indexes
          */
         bool operator==( const Constraint& other ) const;
 
         inline bool operator!=( const Constraint& other ) const {
             return !operator==( other );
         }
 
         /*!\internal*/
         uint hash() const;
 #ifndef QT_NO_DEBUG_STREAM
         QDebug debug( QDebug dbg) const;
 #endif
 
     private:
         QSharedDataPointer<Private> d;
     };
 
     inline uint qHash( const Constraint& c ) {return c.hash();}
 }
 
 #ifndef QT_NO_DEBUG_STREAM
 QDebug KGANTT_EXPORT operator<<( QDebug dbg, const KGantt::Constraint& c );
 #endif /* QT_NO_DEBUG_STREAM */
 
 #endif /* KGANTTCONSTRAINT_H */