/* * Copyright (C) 2013-2015, 2019 by the Konclude Developer Team. * * This file is part of the reasoning system Konclude. * For details and support, see . * * Konclude is free software: you can redistribute it and/or modify * it under the terms of version 3 of the GNU Lesser General Public * License (LGPLv3) as published by the Free Software Foundation. * * Konclude is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU (Lesser) General Public License for more details. * * You should have received a copy of the GNU (Lesser) General Public * License along with Konclude. If not, see . * * This file incorporates work covered by the following copyright and * permission notice (to be compatible with LGPLv2.1, * this code is available/released under GPLv3, * see https://www.gnu.org/licenses/gpl-faq.html#AllCompatibility): * * * Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies). * Contact: http://www.qt-project.org/legal * * This file is part of the QtCore module of the Qt Toolkit. * * $QT_BEGIN_LICENSE:LGPL$ * Commercial License Usage * Licensees holding valid commercial Qt licenses may use this file in * accordance with the commercial license agreement provided with the * Software or, alternatively, in accordance with the terms contained in * a written agreement between you and Digia. For licensing terms and * conditions see http://qt.digia.com/licensing. For further information * use the contact form at http://qt.digia.com/contact-us. * * GNU Lesser General Public License Usage * Alternatively, this file may be used under the terms of the GNU Lesser * General Public License version 2.1 as published by the Free Software * Foundation and appearing in the file LICENSE.LGPL included in the * packaging of this file. Please review the following information to * ensure the GNU Lesser General Public License version 2.1 requirements * will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. * * In addition, as a special exception, Digia gives you certain additional * rights. These rights are described in the Digia Qt LGPL Exception * version 1.1, included in the file LGPL_EXCEPTION.txt in this package. * * GNU General Public License Usage * Alternatively, this file may be used under the terms of the GNU * General Public License version 3.0 as published by the Free Software * Foundation and appearing in the file LICENSE.GPL included in the * packaging of this file. Please review the following information to * ensure the GNU General Public License version 3.0 requirements will be * met: http://www.gnu.org/copyleft/gpl.html. * * * $QT_END_LICENSE$ * * */ #ifndef KONCLUDE_UTILITIES_CONTAINER_CQTMANAGEDRESTRICTEDMODIFICATIONHASH_H #define KONCLUDE_UTILITIES_CONTAINER_CQTMANAGEDRESTRICTEDMODIFICATIONHASH_H // Namespace includes #include "ContainerSettings.h" #include "CQtManagedRestrictedModificationHashBase.h" #include "CQtManagedRestrictedModificationHashData.h" #include "CQtManagedRestrictedModificationList.h" #ifdef KONCLUDE_EMPLOY_QT_MANAGED_RESTRICTED_MODIFICATION_HASH_CONTAINER // Library includes #include // Other includes #include "Context/CContext.h" // Logger includes #include "Logger/CLogger.h" namespace Konclude { using namespace Context; namespace Utilities { namespace Container { /*! * * \class CQtManagedRestrictedModificationHash * \author Andreas Steigmiller * \version 0.1 * \brief TODO * */ template struct CQtManagedRestrictedModificationHashNode { CQtManagedRestrictedModificationHashNode *next; uint h; Key key; T value; inline CQtManagedRestrictedModificationHashNode(const Key &key0) : key(key0) {} // ### remove in 5.0 inline CQtManagedRestrictedModificationHashNode(const Key &key0, const T &value0) : key(key0), value(value0) {} inline bool same_key(uint h0, const Key &key0) { return h0 == h && key0 == key; } }; template struct CQtManagedRestrictedModificationHashDummyNode { CQtManagedRestrictedModificationHashDummyNode *next; uint h; Key key; inline CQtManagedRestrictedModificationHashDummyNode(const Key &key0) : key(key0) {} }; struct CQtManagedRestrictedModificationHashDummyValue { }; inline bool operator==(const CQtManagedRestrictedModificationHashDummyValue & /* v1 */, const CQtManagedRestrictedModificationHashDummyValue & /* v2 */) { return true; } template class CQtManagedRestrictedModificationHash : public CQtManagedRestrictedModificationHashBase { typedef CQtManagedRestrictedModificationHashDummyNode DummyNode; typedef CQtManagedRestrictedModificationHashNode Node; union { CQtManagedRestrictedModificationHashData *d; CQtManagedRestrictedModificationHashNode *e; }; CContext* mContext; CMemoryAllocationManager* mMemMan; static inline Node *concrete(CQtManagedRestrictedModificationHashData::Node *node) { return reinterpret_cast(node); } #ifdef Q_ALIGNOF static inline int alignOfNode() { return qMax(sizeof(void*), Q_ALIGNOF(Node)); } static inline int alignOfDummyNode() { return qMax(sizeof(void*), Q_ALIGNOF(DummyNode)); } #else static inline int alignOfNode() { return 0; } static inline int alignOfDummyNode() { return 0; } #endif public: inline CQtManagedRestrictedModificationHash() : d(&CQtManagedRestrictedModificationHashData::shared_null),mContext(nullptr) { mMemMan = CContext::getMemoryAllocationManager(mContext); /*d->ref.ref();*/ } inline CQtManagedRestrictedModificationHash(CContext* context) : d(&CQtManagedRestrictedModificationHashData::shared_null),mContext(context) { mMemMan = CContext::getMemoryAllocationManager(mContext); /*d->ref.ref();*/ } inline CQtManagedRestrictedModificationHash(const CQtManagedRestrictedModificationHash &other) : d(other.d),mContext(nullptr) { mMemMan = CContext::getMemoryAllocationManager(mContext); /* d->ref.ref();*/ if (!d->sharable) detach(); } inline CQtManagedRestrictedModificationHash(const CQtManagedRestrictedModificationHash &other, CContext* context) : d(other.d),mContext(context) { mMemMan = CContext::getMemoryAllocationManager(mContext); /* d->ref.ref();*/ if (!d->sharable) detach(); } inline ~CQtManagedRestrictedModificationHash() { if (/*!d->ref.deref()*/ d->refHash == this) freeData(d); } CQtManagedRestrictedModificationHash* init(CContext* context = nullptr); CQtManagedRestrictedModificationHash* init(const CQtManagedRestrictedModificationHash &other, CContext* context = nullptr); CQtManagedRestrictedModificationHash* init(CQtManagedRestrictedModificationHash *other, CContext* context = nullptr); CQtManagedRestrictedModificationHash &operator=(const CQtManagedRestrictedModificationHash &other); bool operator==(const CQtManagedRestrictedModificationHash &other) const; inline bool operator!=(const CQtManagedRestrictedModificationHash &other) const { return !(*this == other); } inline int size() const { return d->size; } inline bool isEmpty() const { return d->size == 0; } inline int capacity() const { return d->numBuckets; } void reserve(int size); inline void squeeze() { reserve(1); } inline void detach() { if (/*d->ref != 1*/d->refHash != this) detach_helper(); } inline void detachRestrictedCopy(void* assistValue) { if (/*d->ref != 1*/d->refHash != this) detach_helper_RestrictedCopy(assistValue); } inline bool isDetached() const { return /*d->ref == 1;*/ d->refHash == this; } inline void setSharable(bool sharable) { if (!sharable) detach(); d->sharable = sharable; } void clear(); int remove(const Key &key); T take(const Key &key); bool contains(const Key &key) const; const Key key(const T &value) const; const Key key(const T &value, const Key &defaultKey) const; const T value(const Key &key) const; const T value(const Key &key, const T &defaultValue) const; T &operator[](const Key &key); const T operator[](const Key &key) const; bool tryGetValuePointer(const Key& key, T*& valuePointer) const; bool tryGetValue(const Key& key, T* value = nullptr) const; T* valuePointer(const Key& key) const; QList uniqueKeys() const; QList keys() const; QList keys(const T &value) const; QList values() const; QList values(const Key &key) const; CQtManagedRestrictedModificationList uniqueKeysInManagedRestrictedModificationList(CContext* context = nullptr) const; CQtManagedRestrictedModificationList keysInManagedRestrictedModificationList(CContext* context = nullptr) const; CQtManagedRestrictedModificationList keysInManagedRestrictedModificationList(const T &value, CContext* context = nullptr) const; CQtManagedRestrictedModificationList valuesInManagedRestrictedModificationList(CContext* context = nullptr) const; CQtManagedRestrictedModificationList valuesInManagedRestrictedModificationList(const Key &key, CContext* context = nullptr) const; int count(const Key &key) const; class const_iterator; class iterator { friend class const_iterator; CQtManagedRestrictedModificationHashData::Node *i; public: typedef std::bidirectional_iterator_tag iterator_category; typedef ptrdiff_t difference_type; typedef T value_type; typedef T *pointer; typedef T &reference; // ### Qt 5: get rid of 'operator Node *' inline operator Node *() const { return concrete(i); } inline iterator() : i(0) { } explicit inline iterator(void *node) : i(reinterpret_cast(node)) { } inline const Key &key() const { return concrete(i)->key; } inline T &value() const { return concrete(i)->value; } inline T &operator*() const { return concrete(i)->value; } inline T *operator->() const { return &concrete(i)->value; } inline bool operator==(const iterator &o) const { return i == o.i; } inline bool operator!=(const iterator &o) const { return i != o.i; } inline iterator &operator++() { i = CQtManagedRestrictedModificationHashData::nextNode(i); return *this; } inline iterator operator++(int) { iterator r = *this; i = CQtManagedRestrictedModificationHashData::nextNode(i); return r; } inline iterator &operator--() { i = CQtManagedRestrictedModificationHashData::previousNode(i); return *this; } inline iterator operator--(int) { iterator r = *this; i = CQtManagedRestrictedModificationHashData::previousNode(i); return r; } inline iterator operator+(int j) const { iterator r = *this; if (j > 0) while (j--) ++r; else while (j++) --r; return r; } inline iterator operator-(int j) const { return operator+(-j); } inline iterator &operator+=(int j) { return *this = *this + j; } inline iterator &operator-=(int j) { return *this = *this - j; } // ### Qt 5: not sure this is necessary anymore #ifdef QT_STRICT_ITERATORS private: #else public: #endif inline bool operator==(const const_iterator &o) const { return i == o.i; } inline bool operator!=(const const_iterator &o) const { return i != o.i; } private: // ### Qt 5: remove inline operator bool() const { return false; } }; friend class iterator; class const_iterator { friend class iterator; CQtManagedRestrictedModificationHashData::Node *i; public: typedef std::bidirectional_iterator_tag iterator_category; typedef ptrdiff_t difference_type; typedef T value_type; typedef const T *pointer; typedef const T &reference; // ### Qt 5: get rid of 'operator Node *' inline operator Node *() const { return concrete(i); } inline const_iterator() : i(0) { } explicit inline const_iterator(void *node) : i(reinterpret_cast(node)) { } #ifdef QT_STRICT_ITERATORS explicit inline const_iterator(const iterator &o) #else inline const_iterator(const iterator &o) #endif { i = o.i; } inline const Key &key() const { return concrete(i)->key; } inline const T &value() const { return concrete(i)->value; } inline const T &operator*() const { return concrete(i)->value; } inline const T *operator->() const { return &concrete(i)->value; } inline bool operator==(const const_iterator &o) const { return i == o.i; } inline bool operator!=(const const_iterator &o) const { return i != o.i; } inline const_iterator &operator++() { i = CQtManagedRestrictedModificationHashData::nextNode(i); return *this; } inline const_iterator operator++(int) { const_iterator r = *this; i = CQtManagedRestrictedModificationHashData::nextNode(i); return r; } inline const_iterator &operator--() { i = CQtManagedRestrictedModificationHashData::previousNode(i); return *this; } inline const_iterator operator--(int) { const_iterator r = *this; i = CQtManagedRestrictedModificationHashData::previousNode(i); return r; } inline const_iterator operator+(int j) const { const_iterator r = *this; if (j > 0) while (j--) ++r; else while (j++) --r; return r; } inline const_iterator operator-(int j) const { return operator+(-j); } inline const_iterator &operator+=(int j) { return *this = *this + j; } inline const_iterator &operator-=(int j) { return *this = *this - j; } // ### Qt 5: not sure this is necessary anymore #ifdef QT_STRICT_ITERATORS private: inline bool operator==(const iterator &o) const { return operator==(const_iterator(o)); } inline bool operator!=(const iterator &o) const { return operator!=(const_iterator(o)); } #endif private: // ### Qt 5: remove inline operator bool() const { return false; } }; friend class const_iterator; // STL style inline iterator begin() { detach(); return iterator(d->firstNode()); } inline const_iterator begin() const { return const_iterator(d->firstNode()); } inline const_iterator constBegin() const { return const_iterator(d->firstNode()); } inline iterator end() { detach(); return iterator(e); } inline const_iterator end() const { return const_iterator(e); } inline const_iterator constEnd() const { return const_iterator(e); } iterator erase(iterator it); // more Qt typedef iterator Iterator; typedef const_iterator ConstIterator; inline int count() const { return d->size; } iterator find(const Key &key); const_iterator find(const Key &key) const; const_iterator constFind(const Key &key) const; iterator insert(const Key &key, const T &value); iterator insertMulti(const Key &key, const T &value); CQtManagedRestrictedModificationHash &unite(const CQtManagedRestrictedModificationHash &other); // STL compatibility typedef T mapped_type; typedef Key key_type; typedef ptrdiff_t difference_type; typedef int size_type; inline bool empty() const { return isEmpty(); } #ifdef QT_CQTMANAGEDONEWAYMUTATIONHASH_DEBUG inline void dump() const { d->dump(); } inline void checkSanity() const { d->checkSanity(); } #endif private: void detach_helper(); void detach_helper_RestrictedCopy(void* assistValue); void freeData(CQtManagedRestrictedModificationHashData *d); Node **findNode(const Key &key, uint *hp = 0) const; Node *createNode(uint h, const Key &key, const T &value, Node **nextNode); void deleteNode(Node *node); static void deleteNode2(CQtManagedRestrictedModificationHashData::Node *node); static void duplicateNode(CQtManagedRestrictedModificationHashData::Node *originalNode, void *newNode); static bool copyRestricted_helper(CQtManagedRestrictedModificationHashData::Node *originalNode, void* assistValue); }; }; // end namespace Container }; // end namespace Utilities }; // end namespace Konclude #include "CQtManagedRestrictedModificationHash.cpp" #endif // KONCLUDE_EMPLOY_QT_MANAGED_RESTRICTED_MODIFICATION_HASH_CONTAINER #endif // KONCLUDE_UTILITIES_CONTAINER_CQTMANAGEDRESTRICTEDMODIFICATIONHASH_H