From d777bca65566bf15e9e2ed8b23f854fb974c902a Mon Sep 17 00:00:00 2001 From: Andreas Stöckel Date: Fri, 21 Nov 2014 12:08:09 +0100 Subject: refactored ManagedContainer to own header, added (currently untested) ManagedMap class --- src/core/Managed.hpp | 191 ----------------------------------------- src/core/ManagedContainers.hpp | 111 ++++++++++++++---------- 2 files changed, 68 insertions(+), 234 deletions(-) (limited to 'src/core') diff --git a/src/core/Managed.hpp b/src/core/Managed.hpp index 3386ff8..6199e33 100644 --- a/src/core/Managed.hpp +++ b/src/core/Managed.hpp @@ -737,197 +737,6 @@ public: Managed *getOwner() const { return owner; } }; -/** - * Template class which can be used to collect "Owned" refrences to a certain - * type of managed object. This class should be used in favour of other - * collections of handles, it takes care of acquiring an owned handle from the - * owner of this collection whenever a new element is added. - * - * @param T is the type of the Managed object that should be managed. - * @param Collection should be a stl container of Owned - */ -template -class ManagedCollection { -public: - using collection_type = Collection; - using value_type = typename collection_type::value_type; - using reference = typename collection_type::reference; - using const_reference = typename collection_type::const_reference; - using iterator = typename collection_type::iterator; - using const_iterator = typename collection_type::const_iterator; - using size_type = typename collection_type::size_type; - -private: - Handle owner; - collection_type c; - -protected: - /** - * Function which can be overridden by child classes to execute special code - * whenever a new element is added to the collection. - */ - virtual void addManaged(Handle h) {} - - /** - * Function which can be overriden by child classes to execute special code - * whenever an element is removed from the collection. - */ - virtual void deleteManaged(Handle h) {} - -public: - /** - * Default constructor. - * - * @param owner is the managed object which owns the collection and all - * handles to other managed objects stored within. - */ - ManagedCollection(Handle owner) : owner(owner){}; - - /** - * Initialize with an iterator from another collection. - * - * @param owner is the managed object which owns the collection and all - * handles to other managed objects stored within. - * @param first is an iterator pointing at the first element to be copied - * from some other collection. - * @param last is an iterator pointing at the last element to be copied - * from some other collection. - */ - template - ManagedCollection(Handle owner, InputIterator first, - InputIterator last) - : owner(owner) - { - insert(c.begin, first, last); - } - - /** - * Initialize with another collection. - * - * @param owner is the managed object which owns the collection and all - * handles to other managed objects stored within. - * @param in is a reference at some other collection with content that - * should be copied. - */ - template - ManagedCollection(Handle owner, const InputCollection &in) - : owner(owner) - { - for (const auto &e : in) { - push_back(e); - } - } - - /** - * Virtual destructor. - */ - virtual ~ManagedCollection(){}; - - /* State functions */ - size_type size() const noexcept { return c.size(); } - bool empty() const noexcept { return c.empty(); } - - /* Front and back */ - reference front() { return c.front(); } - const_reference front() const { return c.front(); } - reference back() { return c.back(); } - const_reference back() const { return c.back(); } - - /* Iterators */ - iterator begin() { return c.begin(); } - iterator end() { return c.end(); } - - iterator rbegin() { return c.rbegin(); } - iterator rend() { return c.rend(); } - - const_iterator begin() const { return c.cbegin(); } - const_iterator end() const { return c.cend(); } - - const_iterator cbegin() const { return c.cbegin(); } - const_iterator cend() const { return c.cend(); } - - const_iterator rbegin() const { return c.crbegin(); } - const_iterator rend() const { return c.crend(); } - - const_iterator crbegin() const { return c.crbegin(); } - const_iterator crend() const { return c.crend(); } - - /* Insert and delete operations */ - - iterator insert(const_iterator position, Handle h) - { - Rooted rooted{h}; - addManaged(rooted); - return c.insert(position, owner->acquire(h)); - } - - template - iterator insert(const_iterator position, InputIterator first, - InputIterator last) - { - for (InputIterator it = first; it != last; it++) { - position = insert(position, *it); - position++; - } - } - - iterator erase(iterator position) - { - deleteManaged(*position); - return c.erase(position); - } - - iterator erase(iterator first, iterator last) - { - for (const_iterator it = first; it != last; it++) { - deleteManaged(*it); - } - return c.erase(first, last); - } - - iterator find(const Handle h) { - for (iterator it = begin(); it != end(); it++) { - if (*it == h) { - return it; - } - } - return end(); - } - - const_iterator find(const Handle h) const { - for (const_iterator it = cbegin(); it != cend(); it++) { - if (*it == h) { - return it; - } - } - return cend(); - } - - void push_back(Handle h) - { - Rooted rooted{h}; - addManaged(rooted); - c.push_back(owner->acquire(rooted)); - } - - void pop_back() - { - if (!empty()) { - deleteElement(c.back()); - } - c.pop_back(); - } -}; - -/** - * Special type of ManagedCollection based on a STL vector. - */ -template -class ManagedVector : public ManagedCollection>> { -public: - using ManagedCollection>>::ManagedCollection; -}; - } #endif /* _OUSIA_MANAGED_HPP_ */ diff --git a/src/core/ManagedContainers.hpp b/src/core/ManagedContainers.hpp index c1787b4..9d3dc96 100644 --- a/src/core/ManagedContainers.hpp +++ b/src/core/ManagedContainers.hpp @@ -119,9 +119,19 @@ public: * @param Collection should be a STL list container of Owned */ template -class ManagedGenericList : public ManagedContainer() { +class ManagedGenericList : public ManagedContainer { +private: + using Base = ManagedContainer; + public: - using ManagedContainer::ManagedContainer; + using Base::ManagedContainer; + using collection_type = typename Base::collection_type; + using value_type = typename Base::value_type; + using reference = typename Base::reference; + using const_reference = typename Base::const_reference; + using iterator = typename Base::iterator; + using const_iterator = typename Base::const_iterator; + using size_type = typename Base::size_type; /** * Initialize with an iterator from another collection. @@ -134,10 +144,11 @@ public: * from some other collection. */ template - ManagedGenericList(Handle owner, InputIterator first, InputIterator last) + ManagedGenericList(Handle owner, InputIterator first, + InputIterator last) : ManagedContainer(owner) { - insert(c.begin(), first, last); + insert(Base::c.begin(), first, last); } /** @@ -158,29 +169,29 @@ public: } /* Front and back */ - reference front() { return c.front(); } - const_reference front() const { return c.front(); } - reference back() { return c.back(); } - const_reference back() const { return c.back(); } + reference front() { return Base::c.front(); } + const_reference front() const { return Base::c.front(); } + reference back() { return Base::c.back(); } + const_reference back() const { return Base::c.back(); } /* Insert and delete operations */ iterator insert(const_iterator position, Handle h) { - value_type v = owner->acquire(h); + value_type v = Base::owner->acquire(h); addManaged(v); - return c.insert(position, owner->acquire(h)); + return Base::c.insert(position, v); } template iterator insert(const_iterator position, InputIterator first, InputIterator last) { - bool first = true; + bool atStart = true; const_iterator pos = position; for (InputIterator it = first; it != last; it++) { - if (first) { - first = false; + if (atStart) { + atStart = false; } else { pos++; } @@ -191,51 +202,51 @@ public: iterator find(const Handle h) { - for (iterator it = begin(); it != end(); it++) { + for (iterator it = Base::begin(); it != Base::end(); it++) { if (*it == h) { return it; } } - return end(); + return Base::end(); } const_iterator find(const Handle h) const { - for (const_iterator it = cbegin(); it != cend(); it++) { + for (const_iterator it = Base::cbegin(); it != Base::cend(); it++) { if (*it == h) { return it; } } - return cend(); + return Base::cend(); } void push_back(Handle h) { - Rooted rooted{h}; - addManaged(rooted); - c.push_back(owner->acquire(rooted)); + value_type v = Base::owner->acquire(h); + this->addManaged(v); + Base::c.push_back(v); } void pop_back() { - if (!empty()) { - deleteElement(c.back()); + if (!Base::empty()) { + this->deleteManaged(back()); } - c.pop_back(); + Base::c.pop_back(); } iterator erase(iterator position) { - deleteManaged(*position); - return c.erase(position); + this->deleteManaged(*position); + return Base::c.erase(position); } iterator erase(iterator first, iterator last) { for (const_iterator it = first; it != last; it++) { - deleteManaged(*it); + this->deleteManaged(*it); } - return c.erase(first, last); + return Base::c.erase(first, last); } }; @@ -243,15 +254,29 @@ public: * Special type of ManagedContainer based on an STL map. */ template -class ManagedGenericMap : public ManagedCollection { +class ManagedGenericMap : public ManagedContainer { +private: + using Base = ManagedContainer; + +public: + using Base::ManagedContainer; + using collection_type = typename Base::collection_type; + using value_type = typename Base::value_type; + using key_type = typename Base::key_type; + using reference = typename Base::reference; + using const_reference = typename Base::const_reference; + using iterator = typename Base::iterator; + using const_iterator = typename Base::const_iterator; + using size_type = typename Base::size_type; + private: value_type acquirePair(std::pair> val) { - return std::pair{val->first, owner->acquire(val->second)}; + return std::pair{val->first, + Base::owner->acquire(val->second)}; } public: - /** * Initialize with an iterator from another collection. * @@ -263,7 +288,8 @@ public: * from some other collection. */ template - ManagedGenericMap(Handle owner, InputIterator first, InputIterator last) + ManagedGenericMap(Handle owner, InputIterator first, + InputIterator last) : ManagedContainer(owner) { insert(first, last); @@ -290,14 +316,14 @@ public: { value_type v = acquirePair(val); addManaged(v); - return c.insert(v); + return Base::c.insert(v); } iterator insert(const_iterator position, std::pair> val) { value_type v = acquirePair(val); addManaged(v); - return c.insert(position, v); + return Base::c.insert(position, v); } template @@ -310,14 +336,14 @@ public: iterator erase(const_iterator position) { - deleteManaged(*position); - return c.erase(position); + Base::deleteManaged(*position); + return Base::c.erase(position); } size_t erase(const key_type &k) { iterator pos = find(k); - if (pos != end()) { + if (pos != Base::end()) { erase(pos); return 1; } @@ -327,13 +353,13 @@ public: iterator erase(const_iterator first, const_iterator last) { for (const_iterator it = first; it != last; it++) { - deleteManaged(*it); + Base::deleteManaged(*it); } - return c.erase(first, last); + return Base::c.erase(first, last); } - iterator find(const key_type &k) { return c.find(k); } - const_iterator find(const key_type &k) const { return c.find(k); } + iterator find(const key_type &k) { return Base::c.find(k); } + const_iterator find(const key_type &k) const { return Base::c.find(k); } }; /** @@ -342,7 +368,7 @@ public: template class ManagedVector : public ManagedGenericList>> { public: - using ManagedContainer>>::ManagedContainer; + using ManagedGenericList>>::ManagedGenericList; }; /** @@ -351,9 +377,8 @@ public: template class ManagedMap : public ManagedGenericMap>> { public: - using ManagedGenericMap>>::ManagedMap; + using ManagedGenericMap>>::ManagedGenericMap; }; - } #endif /* _OUSIA_MANAGED_CONTAINERS_H_ */ -- cgit v1.2.3