TCachedUpdateManagerWrap.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
 
 
#include <istd/IChangeable.h>
 
 
namespace istd
{
 
 
template <class Base>
class TCachedUpdateManagerWrap: virtual public Base
{
public:
       typedef Base BaseClass;
 
       TCachedUpdateManagerWrap();
 
       // reimplemented (istd::IChangeable)
       virtual void BeginChanges(const IChangeable::ChangeSet& changeSet) override;
       virtual void EndChanges(const IChangeable::ChangeSet& changeSet) override;
 
protected:
       bool EnsureCacheValid() const;
       void InvalidateCache(const IChangeable::ChangeSet& changeSet);
       void SetCacheValid();
       virtual bool CalculateCache(const IChangeable::ChangeSet& changeSet);
 
private:
       int m_changesCounter;
       mutable bool m_isCacheValid;
       mutable IChangeable::ChangeSet m_cumulatedSet;
};
 
 
// public inline methods
 
// reimplemented (istd::IChangeable)
 
template <class Base>
void TCachedUpdateManagerWrap<Base>::BeginChanges(const IChangeable::ChangeSet& changeSet)
{
       Q_ASSERT(m_changesCounter >= 0);
 
       InvalidateCache(changeSet);
 
       BaseClass::BeginChanges(changeSet);
 
       ++m_changesCounter;
}
 
 
template <class Base>
void TCachedUpdateManagerWrap<Base>::EndChanges(const IChangeable::ChangeSet& changeSet)
{
       --m_changesCounter;
       Q_ASSERT(m_changesCounter >= 0);
 
       BaseClass::EndChanges(changeSet);
}
 
 
// protected inline methods
 
template <class Base>
inline bool TCachedUpdateManagerWrap<Base>::EnsureCacheValid() const
{
       if (!m_isCacheValid && (m_changesCounter <= 0)){
              m_isCacheValid = true;      // set to avoid recursion
 
              m_isCacheValid = const_cast<TCachedUpdateManagerWrap<Base>*>(this)->CalculateCache(m_cumulatedSet);
 
              m_cumulatedSet.Reset();
       }
 
       return m_isCacheValid;
}
 
 
template <class Base>
void TCachedUpdateManagerWrap<Base>::InvalidateCache(const IChangeable::ChangeSet& changeSet)
{
       m_cumulatedSet += changeSet;
 
       m_isCacheValid = false;
}
 
 
template <class Base>
inline void TCachedUpdateManagerWrap<Base>::SetCacheValid()
{
       m_cumulatedSet.Reset();
 
       m_isCacheValid = true;
}
 
 
template <class Base>
inline bool TCachedUpdateManagerWrap<Base>::CalculateCache(const IChangeable::ChangeSet& /*changeSet*/)
{
       return true;
}
 
 
// public methods
 
template <class Base>
TCachedUpdateManagerWrap<Base>::TCachedUpdateManagerWrap()
:      m_changesCounter(0),
       m_isCacheValid(false)
{
}
 
 
} // namespace istd