IChangeable.h

Go to the documentation of this file.

// SPDX-License-Identifier: LGPL-2.1-or-later OR GPL-2.0-or-later OR GPL-3.0-or-later OR LicenseRef-ACF-Commercial
#pragma once
 
 
// Qt includes
#include <QtCore/QString>
#include <QtCore/QSet>
#include <QtCore/QVariant>
#include <QtCore/QMap>
 
// ACF includes
#include <istd/IPolymorphic.h>
#include <istd/TInterfacePtr.h>
 
 
namespace istd
{
 
 
class IChangeable: virtual public IPolymorphic
{
public:
       typedef QMultiMap<QByteArray,QVariant> ChangeInfoMap;
 
       class ChangeSet
       {
       public:
              ChangeSet();
              explicit ChangeSet(const QString& description);
              explicit ChangeSet(int id1, const QString& description = "");
              ChangeSet(int id1, int id2, const QString& description = "");
              ChangeSet(int id1, int id2, int id3, const QString& description = "");
              ChangeSet(int id1, int id2, int id3, int id4, const QString& description = "");
              ChangeSet(int id1, int id2, int id3, int id4, int id5, const QString& description = "");
              ChangeSet(int id1, int id2, int id3, int id4, int id5, int id6, const QString& description = "");
              ChangeSet(int id1, int id2, int id3, int id4, int id5, int id6, int id7, const QString& description = "");
              ChangeSet(int id1, int id2, int id3, int id4, int id5, int id6, int id7, int id8, const QString& description = "");
              ChangeSet(int id1, int id2, int id3, int id4, int id5, int id6, int id7, int id8, int id9, const QString& description = "");
              ChangeSet(int id1, int id2, int id3, int id4, int id5, int id6, int id7, int id8, int id9, int id10, const QString& description = "");
 
              void Reset();
 
              bool IsEmpty() const;
              bool Contains(int changeId) const;
              bool ContainsExplicit(int changeId, bool singleOnly = false) const;
              bool ContainsAny(const ChangeSet& changeSet) const;
 
              void MaskOut(const ChangeSet& changeSet);
 
              const QString& GetDescription() const;
 
              QSet<int> GetIds() const;
 
              const ChangeInfoMap& GetChangeInfoMap() const;
 
              void SetChangeInfoMap(const ChangeInfoMap& infoMap);
 
              QVariant GetChangeInfo(const QByteArray& key) const;
 
              void SetChangeInfo(const QByteArray& key, const QVariant& value);
 
              ChangeSet operator+(const ChangeSet& changeSet) const;
 
              ChangeSet& operator+=(int changeId);
 
              ChangeSet& operator+=(const QSet<int>& ids);
 
              ChangeSet& operator+=(const ChangeSet& changeSet);
 
       private:
              QSet<int> m_ids;
 
              ChangeInfoMap m_infoMap;
 
              QString m_description;
       };
 
       enum ChangeFlags
       {
              CF_ACF_INTERNAL = 0,
 
              CF_ALL_DATA,
 
              CF_ANY,
 
              CF_DESTROYING,
 
              CF_DELEGATED,
 
              CF_NO_UNDO
       };
 
       enum SupportedOperations
       {
              SO_NONE = 0,
 
              SO_OBSERVE = 1 << 0,
              
              SO_COPY = 1 << 1,
              
              SO_CLONE = 1 << 2,
 
              SO_COMPARE = 1 << 3,
 
              SO_RESET = 1 << 4
       };
 
       enum CompatibilityMode
       {
              CM_STRICT,
              CM_WITHOUT_REFS,
              CM_WITH_REFS,
              CM_CONVERT
       };
 
       virtual int GetSupportedOperations() const;
 
       virtual bool CopyFrom(const IChangeable& object, CompatibilityMode mode = CM_WITHOUT_REFS);
 
       virtual bool IsEqual(const IChangeable& object) const;
 
       virtual istd::TUniqueInterfacePtr<istd::IChangeable> CloneMe(CompatibilityMode mode = CM_WITHOUT_REFS) const;
 
       virtual bool ResetData(CompatibilityMode mode = CM_WITHOUT_REFS);
 
       virtual void BeginChanges(const ChangeSet& changeSet);
 
       virtual void EndChanges(const ChangeSet& changeSet);
 
       virtual void BeginChangeGroup(const ChangeSet& changeSet);
 
       virtual void EndChangeGroup(const ChangeSet& changeSet);
 
       // static methods
       static const ChangeSet& GetNoChanges();
 
       static const ChangeSet& GetAnyChange();
 
       static const ChangeSet& GetAllChanges();
 
       static const ChangeSet& GetDelegatedChanges();
 
protected:
       virtual void OnBeginChanges();
 
       virtual void OnEndChanges(const ChangeSet& changeSet);
 
private:
       // static attributes
       static const ChangeSet s_emptyChanges;
       static const ChangeSet s_anyChanges;
       static const ChangeSet s_allChanges;
       static const ChangeSet s_delegatedChanges;
};
 
 
// public inline methods
 
inline int IChangeable::GetSupportedOperations() const
{
       return SO_NONE;
}
 
 
inline bool IChangeable::CopyFrom(const IChangeable& /*object*/, CompatibilityMode /*mode*/)
{
       return false;
}
 
 
inline bool IChangeable::IsEqual(const IChangeable& /*object*/) const
{
       return false;
}
 
 
inline istd::TUniqueInterfacePtr<istd::IChangeable> IChangeable::CloneMe(CompatibilityMode /*mode*/) const
{
       return istd::TUniqueInterfacePtr<istd::IChangeable>();
}
 
 
inline bool IChangeable::ResetData(CompatibilityMode /*mode*/)
{
       return false;
}
 
 
inline void IChangeable::BeginChanges(const ChangeSet& /*changeSet*/)
{
       OnBeginChanges();
}
 
 
inline void IChangeable::EndChanges(const ChangeSet& changeSet)
{
       OnEndChanges(changeSet);
}
 
 
inline void IChangeable::BeginChangeGroup(const ChangeSet& /*changeSet*/)
{
}
 
 
inline void IChangeable::EndChangeGroup(const ChangeSet& /*changeSet*/)
{
}
 
 
// public static inline methods
inline const IChangeable::ChangeSet& IChangeable::GetNoChanges()
{
       return s_emptyChanges;
}
 
 
inline const IChangeable::ChangeSet& IChangeable::GetAnyChange()
{
       return s_anyChanges;
}
 
 
inline const IChangeable::ChangeSet& IChangeable::GetAllChanges()
{
       return s_allChanges;
}
 
 
inline const IChangeable::ChangeSet& IChangeable::GetDelegatedChanges()
{
       return s_delegatedChanges;
}
 
 
// protected inline methods
 
inline void IChangeable::OnBeginChanges()
{
}
 
 
inline void IChangeable::OnEndChanges(const ChangeSet& /*changeSet*/)
{
}
 
 
typedef istd::TUniqueInterfacePtr<istd::IChangeable> IChangeableUniquePtr;
typedef istd::TSharedInterfacePtr<istd::IChangeable> IChangeableSharedPtr;
 
 
bool AreObjectsEqual(const IChangeable* a, const IChangeable* b);
 
 
} // namespace istd