Tube: Added queue, fixed some ugly pylint stuff

libopenage/tube/datatypes.md

@@ -43,7 +43,7 @@ This container is useful for example for unit lists ...
 Set Container
 ----------------
 
-The set container stores items, just as a normal array would. It keeps track of the existence of the items, but does not guarentee any particular ordering (similar to std::unordered_set). 
+The set container stores items, just as a normal array would. It keeps track of the existence of the items, but does not guarentee any particular ordering (similar to std::unordered_set).
 This Container is useful for any non-indexed data structures, for example projectiles.
 
 Queue Container
@@ -55,4 +55,3 @@ This container is useful for example for action queues and buildung queues.
 
 TUBE FILES
 ============
-

libopenage/tube/map_filter_iterator.h

@@ -10,18 +10,6 @@
 namespace openage {
 namespace tube {
 
-template <typename val_t>
-class TubeIterator {
-public:
-	virtual val_t &value() = 0;
-};
-
-template<typename _T>
-bool valid(const _T &, const tube_time_t &at);
-
-template <class _T>
-using _valid_function_t = bool (*)(const _T&, const tube_time_t &);
-
 template <class key_t,
           class val_t,
           class container_t,
@@ -38,7 +26,6 @@ class TubeMapFilterIterator :
 
 	tube_time_t from;
 	tube_time_t to;
-	tube_time_t now;
 
 public:
 	TubeMapFilterIterator(const iterator_t &base,
@@ -48,15 +35,13 @@ class TubeMapFilterIterator :
 		base{base},
 		container_end{container_end},
 		from{from},
-		to{to},
-		now{from} {}
+		to{to} {}
 
 	TubeMapFilterIterator(const TubeMapFilterIterator &rhs) :
 		base{rhs.base},
 		container_end{rhs.container_end},
 		from{rhs.from},
-		to{rhs.to},
-		now{rhs.now} {}
+		to{rhs.to} {}
 
 	TubeMapFilterIterator &operator =(const TubeMapFilterIterator &rhs) {
 		this->base = rhs.base;
@@ -91,13 +76,11 @@ class TubeMapFilterIterator :
 	}
 
 	virtual bool operator ==(const TubeMapFilterIterator<key_t, val_t, container_t> &rhs) const {
-		return rhs.now != std::numeric_limits<tube_time_t>::infinity()
-			|| this->base == rhs.base;
+		return this->base == rhs.base;
 	}
 
 	virtual bool operator !=(const TubeMapFilterIterator<key_t, val_t, container_t> &rhs) const {
-		return rhs.now == std::numeric_limits<tube_time_t>::infinity()
-			|| this->base != rhs.base;
+		return this->base != rhs.base;
 	}
 
 	virtual bool valid(const tube_time_t &time) {
@@ -113,11 +96,4 @@ class TubeMapFilterIterator :
 	}
 };
 
-template<typename _T>
-bool valid(const _T &t,
-           const tube_time_t& time) {
-	return existent_from(t) <= time && existent_until(t) > time;
-}
-
-
 }} // openage::tube

libopenage/tube/queue_filter_iterator.h

@@ -0,0 +1,100 @@
+// Copyright 2017-2017 the openage authors. See copying.md for legal info.
+
+#pragma once
+
+#include <iterator>
+#include <limits>
+
+#include "tube.h"
+
+namespace openage {
+namespace tube {
+
+template <typename _T>
+class Queue;
+
+template <class val_t,
+          class container_t>
+class TubeQueueFilterIterator :
+	virtual public std::iterator<std::forward_iterator_tag, val_t >,
+	public TubeIterator<val_t>
+{
+	friend class Queue<val_t>;
+protected:
+	typedef typename container_t::iterator iterator_t;
+	iterator_t base;
+	iterator_t container_end;
+
+	tube_time_t from;
+	tube_time_t to;
+
+public:
+	TubeQueueFilterIterator(const iterator_t &base,
+	                        const iterator_t &container_end,
+	                        const tube_time_t &from,
+	                        const tube_time_t &to) :
+		base{base},
+		container_end{container_end},
+		from{from},
+		to{to} {}
+
+	TubeQueueFilterIterator(const TubeQueueFilterIterator &rhs) :
+		base{rhs.base},
+		container_end{rhs.container_end},
+		from{rhs.from},
+		to{rhs.to} {}
+
+	TubeQueueFilterIterator &operator =(const TubeQueueFilterIterator &rhs) {
+		this->base = rhs.base;
+		this->container_end = rhs.container_end;
+		this->from = rhs.from;
+		this->to = rhs.to;
+		return *this;
+	}
+
+	TubeQueueFilterIterator &operator ++() {
+		do {
+			++this->base;
+		} while (this->base != this->container_end &&
+		         (this->base->time() < from ||
+		          this->base->time() > to));
+		return *this;
+	}
+
+	//We only want to Iterate forward - so maybe delete this?
+	//timed_iterator &operator --()
+	//{
+	//	--base;
+	//	return *this;
+	//}
+
+	val_t &operator *() const {
+		return this->base->value;
+	}
+
+	val_t *operator ->() const {
+		return &**this;
+	}
+
+	virtual bool operator ==(const TubeQueueFilterIterator<val_t, container_t> &rhs) const {
+		return this->base == rhs.base;
+	}
+
+	virtual bool operator !=(const TubeQueueFilterIterator<val_t, container_t> &rhs) const {
+		return this->base != rhs.base;
+	}
+
+	virtual bool valid() const {
+
+		if (this->base != this->container_end) {
+			return this->base->time() >= from && this->base->time() < to;
+		}
+		return false;
+	}
+
+	val_t &value() override {
+		return this->base->value;
+	}
+};
+
+}} // openage::tube

libopenage/tube/test/test_container.cpp

@@ -5,8 +5,10 @@
 #include "../tube.h"
 #include "../tube_continuous.h"
 #include "../tube_discrete.h"
+#include "../tube_queue.h"
 
 #include <map>
+#include <set>
 
 namespace openage {
 namespace tube {
@@ -140,6 +142,62 @@ void test_list() {
 }
 
 void test_queue() {
+	Queue<int> q;
+	q.insert(0, 1);
+	q.insert(2, 2);
+	q.insert(4, 3);
+	q.insert(10, 4);
+	q.dump();
+	TESTEQUALS(*q.begin(0), 1);
+	TESTEQUALS(*q.begin(1), 1);
+	TESTEQUALS(*q.begin(2), 2);
+	TESTEQUALS(*q.begin(3), 2);
+	TESTEQUALS(*q.begin(4), 3);
+	TESTEQUALS(*q.begin(5), 3);
+	TESTEQUALS(*q.begin(10), 4);
+	TESTEQUALS(*q.begin(12), 4);
+	TESTEQUALS(*q.begin(100000), 4);
+
+	{
+		std::set<int> reference = {1,2,3};
+		for (auto it = q.between(0,6); it != q.end(); ++it) {
+			auto ri = reference.find(it.value());
+			if (ri != reference.end()) {
+				reference.erase(ri);
+			}
+		}
+		TESTEQUALS(reference.empty(), true);
+	}
+	{
+		std::set<int> reference = {2,3,4};
+		for (auto it = q.between(1,40); it != q.end(); ++it) {
+			auto ri = reference.find(it.value());
+			if (ri != reference.end()) {
+				reference.erase(ri);
+			}
+		}
+		TESTEQUALS(reference.empty(), true);
+	}
+	{
+		std::set<int> reference = {};
+		for (auto it = q.between(30,40); it != q.end(); ++it) {
+			auto ri = reference.find(it.value());
+			if (ri != reference.end()) {
+				reference.erase(ri);
+			}
+		}
+		TESTEQUALS(reference.empty(), true);
+	}
+	{
+		std::set<int> reference = {1,2,3,4};
+		for (auto it = q.between(0,40); it != q.end(); ++it) {
+			auto ri = reference.find(it.value());
+			if (ri != reference.end()) {
+				reference.erase(ri);
+			}
+		}
+		TESTEQUALS(reference.empty(), true);
+	}
 
 }
 

libopenage/tube/tube.h

@@ -22,4 +22,24 @@ tube_time_t existent_until (const _T &t) {
 	return t.existent_until();
 }
 
+template <typename val_t>
+class TubeIterator {
+public:
+	virtual val_t &value() = 0;
+};
+
+template<typename _T>
+bool valid(const _T &, const tube_time_t &at);
+
+template <class _T>
+using _valid_function_t = bool (*)(const _T&, const tube_time_t &);
+
+template<typename _T>
+bool valid(const _T &t,
+           const tube_time_t& time) {
+	return existent_from(t) <= time && existent_until(t) > time;
+}
+
+
+
 }} // openage::tube