refactored ManagedContainer to own header, added (currently untested) ManagedMap class

2 files changed, 68 insertions, 234 deletions

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<T>
- */
-template <class T, class Collection>
-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<Managed> 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<T> 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<T> 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<Managed> 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 <class InputIterator>
-	ManagedCollection(Handle<Managed> 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 <class InputCollection>
-	ManagedCollection(Handle<Managed> 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<T> h)
-	{
-		Rooted<T> rooted{h};
-		addManaged(rooted);
-		return c.insert(position, owner->acquire(h));
-	}
-
-	template <class InputIterator>
-	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<T> h) {
-		for (iterator it = begin(); it != end(); it++) {
-			if (*it == h) {
-				return it;
-			}
-		}
-		return end();
-	}
-
-	const_iterator find(const Handle<T> h) const {
-		for (const_iterator it = cbegin(); it != cend(); it++) {
-			if (*it == h) {
-				return it;
-			}
-		}
-		return cend();
-	}
-
-	void push_back(Handle<T> h)
-	{
-		Rooted<T> 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 T>
-class ManagedVector : public ManagedCollection<T, std::vector<Owned<T>>> {
-public:
-	using ManagedCollection<T, std::vector<Owned<T>>>::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<T>
  */
 template <class T, class Collection>
-class ManagedGenericList : public ManagedContainer() {
+class ManagedGenericList : public ManagedContainer<T, Collection> {
+private:
+	using Base = ManagedContainer<T, Collection>;
+
 public:
-	using ManagedContainer<T, Collection>::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 <class InputIterator>
-	ManagedGenericList(Handle<Managed> owner, InputIterator first, InputIterator last)
+	ManagedGenericList(Handle<Managed> owner, InputIterator first,
+	                   InputIterator last)
 	    : ManagedContainer<T, Collection>(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<T> 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 <class InputIterator>
 	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<T> 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<T> 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<T> h)
 	{
-		Rooted<T> 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 K, class T, class Collection>
-class ManagedGenericMap : public ManagedCollection<T, Collection> {
+class ManagedGenericMap : public ManagedContainer<T, Collection> {
+private:
+	using Base = ManagedContainer<T, Collection>;
+
+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<K, Handle<T>> val)
 	{
-		return std::pair<const K, T>{val->first, owner->acquire(val->second)};
+		return std::pair<const K, T>{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 <class InputIterator>
-	ManagedGenericMap(Handle<Managed> owner, InputIterator first, InputIterator last)
+	ManagedGenericMap(Handle<Managed> owner, InputIterator first,
+	                  InputIterator last)
 	    : ManagedContainer<T, Collection>(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<K, Handle<T>> val)
 	{
 		value_type v = acquirePair(val);
 		addManaged(v);
-		return c.insert(position, v);
+		return Base::c.insert(position, v);
 	}
 
 	template <class InputIterator>
@@ -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 T>
 class ManagedVector : public ManagedGenericList<T, std::vector<Owned<T>>> {
 public:
-	using ManagedContainer<T, std::vector<Owned<T>>>::ManagedContainer;
+	using ManagedGenericList<T, std::vector<Owned<T>>>::ManagedGenericList;
 };
 
 /**
@@ -351,9 +377,8 @@ public:
 template <class K, class T>
 class ManagedMap : public ManagedGenericMap<K, T, std::map<K, Owned<T>>> {
 public:
-	using ManagedGenericMap<K, T, std::map<K, Owned<T>>>::ManagedMap;
+	using ManagedGenericMap<K, T, std::map<K, Owned<T>>>::ManagedGenericMap;
 };
-
 }
 
 #endif /* _OUSIA_MANAGED_CONTAINERS_H_ */