File indexing completed on 2024-05-12 04:38:09

 /*
     SPDX-FileCopyrightText: 2007 David Nolden <david.nolden.kdevelop@art-master.de>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #ifndef KDEVPLATFORM_SETREPOSITORY_H
 #define KDEVPLATFORM_SETREPOSITORY_H
 
 #include "basicsetrepository.h"
 #include <QMutex>
 #include <list>
 
 /**
  * This header defines convenience-class that allow handling set-repositories using the represented higher-level objects instead
  * of indices to them.
  * */
 
 namespace Utils {
 /**
  * Use this class to conveniently iterate over the items in a set.
  * @tparam T The type the indices will be converted to
  * @tparam Conversion Should be a class that has a toIndex member function that takes an object of type T as parameter, and returns an index,
  *                   and a toItem member function that takes an index, and returns an item of type T.
  * */
 template <class T, class Conversion>
 class ConvenientIterator
     : public Conversion
 {
 public:
     explicit ConvenientIterator(const Set::Iterator& it = Set::Iterator()) : m_it(it)
     {
     }
     explicit ConvenientIterator(const Set& set) : m_it(set.iterator())
     {
     }
 
     operator bool() const {
         return m_it;
     }
 
     ConvenientIterator& operator++()
     {
         ++m_it;
         return *this;
     }
 
     T operator*() const
     {
         return Conversion::toItem(*m_it);
     }
 
     uint index() const
     {
         return *m_it;
     }
 
 private:
     Set::Iterator m_it;
 };
 
 struct DummyLocker
 {
 };
 
 template <class T>
 struct IdentityConversion
 {
     static T toIndex(const T& t)
     {
         return t;
     }
     static T toItem(const T& t)
     {
         return t;
     }
 };
 
 ///This is a virtual set-node that allows conveniently iterating through the tree-structure,
 ///accessing the contained items directly, and accessing the ranges.
 template <class T, class Conversion, class StaticRepository>
 class VirtualSetNode
 {
 private:
     using ClassType = VirtualSetNode<T, Conversion, StaticRepository>;
 
 public:
     inline explicit VirtualSetNode(const SetNodeData* data = nullptr) : m_data(data)
     {
     }
 
     inline bool isValid() const
     {
         return ( bool )m_data;
     }
 
     ///If this returns false, a left and a right node are available.
     ///If this returns true, this node represents a single item, that can be retrieved by calling item() or operator*.
     inline bool isFinalNode() const
     {
         return m_data->leftNode() == 0;
     }
 
     inline T firstItem() const
     {
         return Conversion::toItem(start());
     }
 
     inline T lastItem() const
     {
         return Conversion::toItem(end() - 1);
     }
 
     inline T operator*() const
     {
         return Conversion::toItem(start());
     }
 
     inline ClassType leftChild() const
     {
         if (m_data->leftNode())
             return ClassType(StaticRepository::repository()->nodeFromIndex(m_data->leftNode()));
         else
             return ClassType(nullptr);
     }
 
     inline ClassType rightChild() const
     {
         if (m_data->rightNode())
             return ClassType(StaticRepository::repository()->nodeFromIndex(m_data->rightNode()));
         else
             return ClassType(nullptr);
     }
 
     ///Returns the start of this node's range. If this is a final node, the length of the range is 1.
     inline uint start() const
     {
         return m_data->start();
     }
 
     ///Returns the end of this node's range.
     inline uint end() const
     {
         return m_data->end();
     }
 
 private:
 
     const SetNodeData* m_data;
 };
 
 template <class T, class Conversion, class StaticRepository, bool doReferenceCounting = false,
     class StaticAccessLocker = DummyLocker>
 class StorableSet
     : public Conversion
 {
 public:
 
     using Node = VirtualSetNode<T, Conversion, StaticRepository>;
 
     StorableSet(const StorableSet& rhs) : m_setIndex(rhs.m_setIndex)
     {
         StaticAccessLocker lock;
         Q_UNUSED(lock);
         if (doReferenceCounting)
             set().staticRef();
     }
 
     explicit StorableSet(const std::set<uint>& indices)
     {
         StaticAccessLocker lock;
         Q_UNUSED(lock);
         m_setIndex = StaticRepository::repository()->createSet(indices).setIndex();
         if (doReferenceCounting)
             set().staticRef();
     }
 
     StorableSet()
     {
     }
 
     ~StorableSet()
     {
         StaticAccessLocker lock;
         Q_UNUSED(lock);
         if (doReferenceCounting)
             set().staticUnref();
     }
 
     void insert(const T& t)
     {
         insertIndex(Conversion::toIndex(t));
     }
 
     bool isEmpty() const
     {
         return m_setIndex == 0;
     }
 
     uint count() const
     {
         return set().count();
     }
 
     void insertIndex(uint index)
     {
         StaticAccessLocker lock;
         Q_UNUSED(lock);
         Set set(m_setIndex, StaticRepository::repository());
         Set oldSet(set);
         Set addedSet = StaticRepository::repository()->createSet(index);
         if (doReferenceCounting)
             addedSet.staticRef();
         set += addedSet;
         m_setIndex = set.setIndex();
 
         if (doReferenceCounting) {
             set.staticRef();
             oldSet.staticUnref();
             addedSet.staticUnref();
         }
     }
 
     void remove(const T& t)
     {
         removeIndex(Conversion::toIndex(t));
     }
 
     void removeIndex(uint index)
     {
         StaticAccessLocker lock;
         Q_UNUSED(lock);
         Set set(m_setIndex, StaticRepository::repository());
         Set oldSet(set);
         Set removedSet = StaticRepository::repository()->createSet(index);
         if (doReferenceCounting) {
             removedSet.staticRef();
         }
         set -= removedSet;
         m_setIndex = set.setIndex();
 
         if (doReferenceCounting) {
             set.staticRef();
             oldSet.staticUnref();
             removedSet.staticUnref();
         }
     }
 
     Set set() const
     {
         return Set(m_setIndex, StaticRepository::repository());
     }
 
     bool contains(const T& item) const
     {
         return containsIndex(Conversion::toIndex(item));
     }
 
     bool containsIndex(uint index) const
     {
         StaticAccessLocker lock;
         Q_UNUSED(lock);
         Set set(m_setIndex, StaticRepository::repository());
         return set.contains(index);
     }
 
     StorableSet& operator +=(const StorableSet& rhs)
     {
         StaticAccessLocker lock;
         Q_UNUSED(lock);
         Set set(m_setIndex, StaticRepository::repository());
         Set oldSet(set);
         Set otherSet(rhs.m_setIndex, StaticRepository::repository());
         set += otherSet;
         m_setIndex = set.setIndex();
 
         if (doReferenceCounting) {
             set.staticRef();
             oldSet.staticUnref();
         }
         return *this;
     }
 
     StorableSet& operator -=(const StorableSet& rhs)
     {
         StaticAccessLocker lock;
         Q_UNUSED(lock);
         Set set(m_setIndex, StaticRepository::repository());
         Set oldSet(set);
         Set otherSet(rhs.m_setIndex, StaticRepository::repository());
         set -= otherSet;
         m_setIndex = set.setIndex();
 
         if (doReferenceCounting) {
             set.staticRef();
             oldSet.staticUnref();
         }
         return *this;
     }
 
     StorableSet& operator &=(const StorableSet& rhs)
     {
         StaticAccessLocker lock;
         Q_UNUSED(lock);
         Set set(m_setIndex, StaticRepository::repository());
         Set oldSet(set);
         Set otherSet(rhs.m_setIndex, StaticRepository::repository());
         set &= otherSet;
         m_setIndex = set.setIndex();
 
         if (doReferenceCounting) {
             set.staticRef();
             oldSet.staticUnref();
         }
         return *this;
     }
 
     StorableSet& operator=(const StorableSet& rhs)
     {
         StaticAccessLocker lock;
         Q_UNUSED(lock);
         if (doReferenceCounting)
             set().staticUnref();
         m_setIndex = rhs.m_setIndex;
         if (doReferenceCounting)
             set().staticRef();
         return *this;
     }
 
     StorableSet operator +(const StorableSet& rhs) const
     {
         StorableSet ret(*this);
         ret += rhs;
         return ret;
     }
 
     StorableSet operator -(const StorableSet& rhs) const
     {
         StorableSet ret(*this);
         ret -= rhs;
         return ret;
     }
 
     StorableSet operator &(const StorableSet& rhs) const
     {
         StorableSet ret(*this);
         ret &= rhs;
         return ret;
     }
 
     bool operator==(const StorableSet& rhs) const
     {
         return m_setIndex == rhs.m_setIndex;
     }
 
     using Iterator = ConvenientIterator<T, Conversion>;
 
     Iterator iterator() const
     {
         return ConvenientIterator<T, Conversion>(set());
     }
 
     Node node() const
     {
         return Node(StaticRepository::repository()->nodeFromIndex(m_setIndex));
     }
 
     uint setIndex() const
     {
         return m_setIndex;
     }
 
 private:
 
     uint m_setIndex = 0;
 };
 
 template <class T, class Conversion, class StaticRepository, bool doReferenceCounting, class StaticAccessLocker>
 uint qHash(const StorableSet<T, Conversion, StaticRepository, doReferenceCounting, StaticAccessLocker>& set)
 {
     return set.setIndex();
 }
 /** This is a helper-class that helps inserting a bunch of items into a set without caring about grouping them together.
  *
  * It creates a much better tree-structure if many items are inserted at one time, and this class helps doing that in
  * cases where there is no better choice then storing a temporary list of items and inserting them all at once.
  *
  * This set will then care about really inserting them into the repository once the real set is requested.
  *
  * @todo eventually make this unnecessary
  *
  * @tparam T Should be the type that should be dealt
  * @tparam Conversion Should be a class that has a toIndex member function that takes an object of type T as parameter, and returns an index,
  *                   and a toItem member function that takes an index, and returns an item of type T.
  **/
 template <class T, class Conversion>
 class LazySet
     : public Conversion
 {
 public:
     /** @param rep The repository the set should belong/belongs to
      *  @param lockBeforeAccess If this is nonzero, the given mutex will be locked before each modification to the repository.
      *  @param basicSet If this is explicitly given, the given set will be used as base. However it will not be changed.
      *
      * @warning Watch for deadlocks, never use this class while the mutex given through lockBeforeAccess is locked
      */
     explicit LazySet(BasicSetRepository* rep, QMutex* lockBeforeAccess = nullptr, const Set& basicSet = Set()) : m_rep(
             rep)
         , m_set(basicSet)
         , m_lockBeforeAccess(lockBeforeAccess)
     {
     }
 
     void insert(const T& t)
     {
         if (!m_temporaryRemoveIndices.empty())
             apply();
         m_temporaryIndices.insert(Conversion::toIndex(t));
     }
 
     void insertIndex(uint index)
     {
         if (!m_temporaryRemoveIndices.empty())
             apply();
         m_temporaryIndices.insert(index);
     }
 
     void remove(const T& t)
     {
         if (!m_temporaryIndices.empty())
             apply();
         m_temporaryRemoveIndices.insert(Conversion::toIndex(t));
     }
 
     ///Returns the set this LazySet represents. When this is called, the set is constructed in the repository.
     Set set() const
     {
         apply();
         return m_set;
     }
 
     ///@warning this is expensive, because the set is constructed
     bool contains(const T& item) const
     {
         QMutexLocker l(m_lockBeforeAccess);
         uint index = Conversion::toIndex(item);
 
         if (m_temporaryRemoveIndices.empty()) {
             //Simplification without creating the set
             if (m_temporaryIndices.find(index) != m_temporaryIndices.end())
                 return true;
 
             return m_set.contains(index);
         }
 
         return set().contains(index);
     }
 
     LazySet& operator +=(const Set& set)
     {
         if (!m_temporaryRemoveIndices.empty())
             apply();
         QMutexLocker l(m_lockBeforeAccess);
         m_set += set;
         return *this;
     }
 
     LazySet& operator -=(const Set& set)
     {
         if (!m_temporaryIndices.empty())
             apply();
         QMutexLocker l(m_lockBeforeAccess);
         m_set -= set;
         return *this;
     }
 
     LazySet operator +(const Set& set) const
     {
         apply();
         QMutexLocker l(m_lockBeforeAccess);
         Set ret = m_set + set;
         return LazySet(m_rep, m_lockBeforeAccess, ret);
     }
 
     LazySet operator -(const Set& set) const
     {
         apply();
         QMutexLocker l(m_lockBeforeAccess);
         Set ret = m_set - set;
         return LazySet(m_rep, m_lockBeforeAccess, ret);
     }
 
     void clear()
     {
         QMutexLocker l(m_lockBeforeAccess);
         m_set = Set();
         m_temporaryIndices.clear();
         m_temporaryRemoveIndices.clear();
     }
 
     ConvenientIterator<T, Conversion> iterator() const
     {
         apply();
         return ConvenientIterator<T, Conversion>(set());
     }
 
 private:
     void apply() const
     {
         if (!m_temporaryIndices.empty()) {
             QMutexLocker l(m_lockBeforeAccess);
             Set tempSet = m_rep->createSet(m_temporaryIndices);
             m_temporaryIndices.clear();
             m_set += tempSet;
         }
         if (!m_temporaryRemoveIndices.empty()) {
             QMutexLocker l(m_lockBeforeAccess);
             Set tempSet = m_rep->createSet(m_temporaryRemoveIndices);
             m_temporaryRemoveIndices.clear();
             m_set -= tempSet;
         }
     }
     BasicSetRepository* m_rep;
     mutable Set m_set;
     QMutex* m_lockBeforeAccess;
     using IndexList = std::set<Utils::BasicSetRepository::Index>;
     mutable IndexList m_temporaryIndices;
     mutable IndexList m_temporaryRemoveIndices;
 };
 
 ///Persistent repository that manages string-sets, also correctly increasing the string reference-counts as needed
 struct KDEVPLATFORMLANGUAGE_EXPORT StringSetRepository
     : public Utils::BasicSetRepository
 {
     explicit StringSetRepository(const QString& name, QRecursiveMutex* mutex);
     void itemRemovedFromSets(uint index) override;
     void itemAddedToSets(uint index) override;
 };
 }
 
 #endif