TModelWrap.h

Go to the documentation of this file.

/********************************************************************************
**  This file is part of the ICF Framework. Copyright (C) Witold Gantzke & Kirill Lepskiy
**  ICF Framework may be used under the terms of the LGPL License v. 2.1 by the Free Software Foundation.
********************************************************************************/
 
#ifndef imod_TModelWrap_included
#define imod_TModelWrap_included
 
 
// ICF includes
#include <istd/IChangeable.h>
#include <iser/TCopySerializedWrap.h>
#include <imod/CModelBase.h>
 
 
namespace imod
{
 
 
template <class Base>
class TModelWrap: public iser::TCopySerializedWrap<Base>, public imod::CModelBase
{
public:
    typedef iser::TCopySerializedWrap<Base> BaseClass;
    typedef imod::CModelBase BaseClass2;
 
    template<typename... Args>
    TModelWrap(Args&&... args): BaseClass(args...){}
 
    void SetBaseObject(const Base& baseObject);
 
    // pseudo-reimplemented (istd::IChangeable)
    int GetSupportedOperations() const override;
    std::unique_ptr<istd::IChangeable> CloneMe(istd::IChangeable::CompatibilityMode mode = istd::IChangeable::CM_WITHOUT_REFS) const override;
    QMutex* GetChangesLock() const override;
    void BeginChanges(const istd::IChangeable::ChangeSet& changeSet) override;
    void EndChanges(const istd::IChangeable::ChangeSet& changeSet) override;
    void BeginChangeGroup(const istd::IChangeable::ChangeSet& changeSet) override;
    void EndChangeGroup(const istd::IChangeable::ChangeSet& changeSet) override;
 
protected:
    // reimplemented (imod::CModelBase)
    void OnBeginGlobalChanges() override;
    void OnEndGlobalChanges(const istd::IChangeable::ChangeSet& changeSet) override;
 
private:
    Q_DISABLE_COPY(TModelWrap);
 
    mutable QMutex m_changesLock;
};
 
 
// public methods
 
template <class Base>
void TModelWrap<Base>::SetBaseObject(const Base& baseObject)
{
    Base::operator=(baseObject);
}
 
 
// pseudo-reimplemented (istd::IChangeable)
 
template <class Base>
int TModelWrap<Base>::GetSupportedOperations() const
{
    int baseOperations = Base::GetSupportedOperations();
 
    if constexpr (std::is_constructible_v<Base>) {
        return baseOperations | istd::IChangeable::SO_CLONE | istd::IChangeable::SO_OBSERVE;
    }
    else {
        return baseOperations | istd::IChangeable::SO_OBSERVE;
    }
}
 
 
template <class Base>
std::unique_ptr<istd::IChangeable> TModelWrap<Base>::CloneMe(istd::IChangeable::CompatibilityMode mode) const
{
    if constexpr (std::is_constructible_v<Base>) {
        std::unique_ptr<istd::IChangeable> clonePtr{new TModelWrap<Base>()};
 
        if (clonePtr->CopyFrom(*this, mode)){
            return clonePtr;
        }
    }
 
    return nullptr;
}
 
 
template <class Base>
QMutex* TModelWrap<Base>::GetChangesLock() const
{
    return &m_changesLock;
}
 
 
template <class Base>
void TModelWrap<Base>::BeginChanges(const istd::IChangeable::ChangeSet& changeSet)
{
    BaseClass2::NotifyBeforeChange(changeSet, false);
}
 
 
template <class Base>
void TModelWrap<Base>::EndChanges(const istd::IChangeable::ChangeSet& changeSet)
{
    BaseClass2::NotifyAfterChange(changeSet);
}
 
 
template <class Base>
void TModelWrap<Base>::BeginChangeGroup(const istd::IChangeable::ChangeSet& changeSet)
{
    BaseClass2::NotifyBeforeChange(changeSet, true);
}
 
 
template <class Base>
void TModelWrap<Base>::EndChangeGroup(const istd::IChangeable::ChangeSet& changeSet)
{
    BaseClass2::NotifyAfterChange(changeSet);
}
 
 
// protected methods
 
// reimplemented (imod::CModelBase)
 
template <class Base>
void TModelWrap<Base>::OnBeginGlobalChanges()
{
    this->OnBeginChanges();
 
    m_changesLock.lock();
}
 
 
template <class Base>
void TModelWrap<Base>::OnEndGlobalChanges(const istd::IChangeable::ChangeSet& changeSet)
{
    m_changesLock.unlock();
 
    this->OnEndChanges(changeSet);
}
 
 
} // namespace imod
 
 
#endif // !imod_TModelWrap_included