/*
* 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