/* * 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_CQTMANAGEDRESTRICTEDMODIFICATIONLIST_H #define KONCLUDE_UTILITIES_CONTAINER_CQTMANAGEDRESTRICTEDMODIFICATIONLIST_H // Namespace includes #include "ContainerSettings.h" #ifdef KONCLUDE_EMPLOY_QT_MANAGED_RESTRICTED_MODIFICATION_LIST_CONTAINER #include "CQtManagedRestrictedModificationListData.h" #include "CQtManagedRestrictedModificationListBase.h" // 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 CQtManagedRestrictedModificationList * \author Andreas Steigmiller * \version 0.1 * \brief TODO * */ template class CQtManagedRestrictedModificationList : public CQtManagedRestrictedModificationListBase { struct Node { void *v; #if defined(Q_CC_BOR) Q_INLINE_TEMPLATE T &t(); #else Q_INLINE_TEMPLATE T &t() { return *reinterpret_cast(QTypeInfo::isLarge || QTypeInfo::isStatic ? v : this); } #endif }; union { CQtManagedRestrictedModificationListData p; CQtManagedRestrictedModificationListData::Data *d; }; CContext* mContext; CMemoryAllocationManager* mMemMan; public: inline CQtManagedRestrictedModificationList() : d(&CQtManagedRestrictedModificationListData::shared_null),mContext(nullptr) { mMemMan = CContext::getMemoryAllocationManager(mContext); /*d->ref.ref();*/ } inline CQtManagedRestrictedModificationList(CContext* context) : d(&CQtManagedRestrictedModificationListData::shared_null),mContext(context) { mMemMan = CContext::getMemoryAllocationManager(mContext); /*d->ref.ref();*/ } inline CQtManagedRestrictedModificationList(const CQtManagedRestrictedModificationList &l) : d(l.d),mContext(nullptr) { mMemMan = CContext::getMemoryAllocationManager(mContext); /*d->ref.ref();*/ if (!d->sharable) detach_helper(); } inline CQtManagedRestrictedModificationList(const CQtManagedRestrictedModificationList &l, CContext* context) : d(l.d),mContext(context) { mMemMan = CContext::getMemoryAllocationManager(mContext); /*d->ref.ref();*/ if (!d->sharable) detach_helper(); } ~CQtManagedRestrictedModificationList(); CQtManagedRestrictedModificationList* init(CContext* context = nullptr); CQtManagedRestrictedModificationList* init(const CQtManagedRestrictedModificationList &other, CContext* context = nullptr); CQtManagedRestrictedModificationList* init(const CQtManagedRestrictedModificationList *other, CContext* context = nullptr); CQtManagedRestrictedModificationList &operator=(const CQtManagedRestrictedModificationList &l); bool operator==(const CQtManagedRestrictedModificationList &l) const; inline bool operator!=(const CQtManagedRestrictedModificationList &l) const { return !(*this == l); } inline int size() const { return p.size(); } inline void detach() { if (d->refList != this/*d->ref != 1*/) detach_helper(); } inline void detachShared() { // The "this->" qualification is needed for GCCE. if (d->refList != this/*d->ref != 1*/ && this->d != &CQtManagedRestrictedModificationListData::shared_null) detach_helper(); } inline bool isDetached() const { return /*d->ref == 1*/d->refList == this; } inline void setSharable(bool sharable) { if (!sharable) detach(); d->sharable = sharable; } inline bool isSharedWith(const CQtManagedRestrictedModificationList &other) const { return d == other.d; } inline bool isEmpty() const { return p.isEmpty(); } void clear(); const T &at(int i) const; const T &operator[](int i) const; T &operator[](int i); void reserve(int size); void append(const T &t); void append(const CQtManagedRestrictedModificationList &t); void prepend(const T &t); void insert(int i, const T &t); void replace(int i, const T &t); void removeAt(int i); int removeAll(const T &t); bool removeOne(const T &t); T takeAt(int i); T takeFirst(); T takeLast(); void move(int from, int to); void swap(int i, int j); int indexOf(const T &t, int from = 0) const; int lastIndexOf(const T &t, int from = -1) const; bool contains(const T &t) const; int count(const T &t) const; class const_iterator; class iterator { public: Node *i; typedef std::random_access_iterator_tag iterator_category; typedef qptrdiff difference_type; typedef T value_type; typedef T *pointer; typedef T &reference; inline iterator() : i(0) {} inline iterator(Node *n) : i(n) {} inline iterator(const iterator &o): i(o.i){} inline T &operator*() const { return i->t(); } inline T *operator->() const { return &i->t(); } inline T &operator[](int j) const { return i[j].t(); } inline bool operator==(const iterator &o) const { return i == o.i; } inline bool operator!=(const iterator &o) const { return i != o.i; } inline bool operator<(const iterator& other) const { return i < other.i; } inline bool operator<=(const iterator& other) const { return i <= other.i; } inline bool operator>(const iterator& other) const { return i > other.i; } inline bool operator>=(const iterator& other) const { return i >= other.i; } #ifndef QT_STRICT_ITERATORS 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 bool operator<(const const_iterator& other) const { return i < other.i; } inline bool operator<=(const const_iterator& other) const { return i <= other.i; } inline bool operator>(const const_iterator& other) const { return i > other.i; } inline bool operator>=(const const_iterator& other) const { return i >= other.i; } #endif inline iterator &operator++() { ++i; return *this; } inline iterator operator++(int) { Node *n = i; ++i; return n; } inline iterator &operator--() { i--; return *this; } inline iterator operator--(int) { Node *n = i; i--; return n; } inline iterator &operator+=(int j) { i+=j; return *this; } inline iterator &operator-=(int j) { i-=j; return *this; } inline iterator operator+(int j) const { return iterator(i+j); } inline iterator operator-(int j) const { return iterator(i-j); } inline int operator-(iterator j) const { return int(i - j.i); } }; friend class iterator; class const_iterator { public: Node *i; typedef std::random_access_iterator_tag iterator_category; typedef qptrdiff difference_type; typedef T value_type; typedef const T *pointer; typedef const T &reference; inline const_iterator() : i(0) {} inline const_iterator(Node *n) : i(n) {} inline const_iterator(const const_iterator &o): i(o.i) {} #ifdef QT_STRICT_ITERATORS inline explicit const_iterator(const iterator &o): i(o.i) {} #else inline const_iterator(const iterator &o): i(o.i) {} #endif inline const T &operator*() const { return i->t(); } inline const T *operator->() const { return &i->t(); } inline const T &operator[](int j) const { return i[j].t(); } 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 bool operator<(const const_iterator& other) const { return i < other.i; } inline bool operator<=(const const_iterator& other) const { return i <= other.i; } inline bool operator>(const const_iterator& other) const { return i > other.i; } inline bool operator>=(const const_iterator& other) const { return i >= other.i; } inline const_iterator &operator++() { ++i; return *this; } inline const_iterator operator++(int) { Node *n = i; ++i; return n; } inline const_iterator &operator--() { i--; return *this; } inline const_iterator operator--(int) { Node *n = i; i--; return n; } inline const_iterator &operator+=(int j) { i+=j; return *this; } inline const_iterator &operator-=(int j) { i-=j; return *this; } inline const_iterator operator+(int j) const { return const_iterator(i+j); } inline const_iterator operator-(int j) const { return const_iterator(i-j); } inline int operator-(const_iterator j) const { return i - j.i; } }; friend class const_iterator; // stl style inline iterator begin() { detach(); return reinterpret_cast(p.begin()); } inline const_iterator begin() const { return reinterpret_cast(p.begin()); } inline const_iterator constBegin() const { return reinterpret_cast(p.begin()); } inline iterator end() { detach(); return reinterpret_cast(p.end()); } inline const_iterator end() const { return reinterpret_cast(p.end()); } inline const_iterator constEnd() const { return reinterpret_cast(p.end()); } iterator insert(iterator before, const T &t); iterator erase(iterator pos); iterator erase(iterator first, iterator last); // more Qt typedef iterator Iterator; typedef const_iterator ConstIterator; inline int count() const { return p.size(); } inline int length() const { return p.size(); } // Same as count() inline T& first() { Q_ASSERT(!isEmpty()); return *begin(); } inline const T& first() const { Q_ASSERT(!isEmpty()); return at(0); } T& last() { Q_ASSERT(!isEmpty()); return *(--end()); } const T& last() const { Q_ASSERT(!isEmpty()); return at(count() - 1); } inline void removeFirst() { Q_ASSERT(!isEmpty()); erase(begin()); } inline void removeLast() { Q_ASSERT(!isEmpty()); erase(--end()); } inline bool startsWith(const T &t) const { return !isEmpty() && first() == t; } inline bool endsWith(const T &t) const { return !isEmpty() && last() == t; } CQtManagedRestrictedModificationList mid(int pos, int length = -1) const; T value(int i) const; T value(int i, const T &defaultValue) const; // stl compatibility inline void push_back(const T &t) { append(t); } inline void push_front(const T &t) { prepend(t); } inline T& front() { return first(); } inline const T& front() const { return first(); } inline T& back() { return last(); } inline const T& back() const { return last(); } inline void pop_front() { removeFirst(); } inline void pop_back() { removeLast(); } inline bool empty() const { return isEmpty(); } typedef int size_type; typedef T value_type; typedef value_type *pointer; typedef const value_type *const_pointer; typedef value_type &reference; typedef const value_type &const_reference; typedef qptrdiff difference_type; #ifdef QT3_SUPPORT inline QT3_SUPPORT iterator remove(iterator pos) { return erase(pos); } inline QT3_SUPPORT int remove(const T &t) { return removeAll(t); } inline QT3_SUPPORT int findIndex(const T& t) const { return indexOf(t); } inline QT3_SUPPORT iterator find(const T& t) { int i = indexOf(t); return (i == -1 ? end() : (begin()+i)); } inline QT3_SUPPORT const_iterator find (const T& t) const { int i = indexOf(t); return (i == -1 ? end() : (begin()+i)); } inline QT3_SUPPORT iterator find(iterator from, const T& t) { int i = indexOf(t, from - begin()); return i == -1 ? end() : begin()+i; } inline QT3_SUPPORT const_iterator find(const_iterator from, const T& t) const { int i = indexOf(t, from - begin()); return i == -1 ? end() : begin()+i; } #endif // comfort CQtManagedRestrictedModificationList &operator+=(const CQtManagedRestrictedModificationList &l); inline CQtManagedRestrictedModificationList operator+(const CQtManagedRestrictedModificationList &l) const { CQtManagedRestrictedModificationList n = *this; n += l; return n; } inline CQtManagedRestrictedModificationList &operator+=(const T &t) { append(t); return *this; } inline CQtManagedRestrictedModificationList &operator<< (const T &t) { append(t); return *this; } inline CQtManagedRestrictedModificationList &operator<<(const CQtManagedRestrictedModificationList &l) { *this += l; return *this; } QVector toVector() const; QSet toSet() const; static CQtManagedRestrictedModificationList fromVector(const QVector &vector); static CQtManagedRestrictedModificationList fromSet(const QSet &set); #ifndef QT_NO_STL static inline CQtManagedRestrictedModificationList fromStdList(const std::list &list) { CQtManagedRestrictedModificationList tmp; qCopy(list.begin(), list.end(), std::back_inserter(tmp)); return tmp; } inline std::list toStdList() const { std::list tmp; qCopy(constBegin(), constEnd(), std::back_inserter(tmp)); return tmp; } #endif private: Node *detach_helper_grow(int i, int n); void detach_helper(int alloc); void detach_helper(); void free(CQtManagedRestrictedModificationListData::Data *d); void node_construct(Node *n, const T &t); void node_destruct(Node *n); void node_copy(Node *from, Node *to, Node *src); void node_destruct(Node *from, Node *to); }; }; // end namespace Container }; // end namespace Utilities }; // end namespace Konclude #include "CQtManagedRestrictedModificationList.cpp" #endif // KONCLUDE_EMPLOY_QT_MANAGED_RESTRICTED_MODIFICATION_LIST_CONTAINER #endif // KONCLUDE_UTILITIES_CONTAINER_CQTMANAGEDRESTRICTEDMODIFICATIONLIST_H