Configurable Activities

libopenage/curve/base_curve.h

@@ -115,7 +115,7 @@ class BaseCurve : public event::EventEntity {
      *              the keyframes of \p other.
      */
 	void sync(const BaseCurve<T> &other,
-	          const time::time_t &start = std::numeric_limits<time::time_t>::min());
+	          const time::time_t &start = time::TIME_MIN);
 
 	/**
      * Copy keyframes from another curve (with a different element type) to this curve.
@@ -134,7 +134,7 @@ class BaseCurve : public event::EventEntity {
 	template <typename O>
 	void sync(const BaseCurve<O> &other,
 	          const std::function<T(const O &)> &converter,
-	          const time::time_t &start = std::numeric_limits<time::time_t>::min());
+	          const time::time_t &start = time::TIME_MIN);
 
 	/**
      * Get the identifier of this curve.
@@ -270,7 +270,7 @@ std::string BaseCurve<T>::str() const {
 
 template <typename T>
 void BaseCurve<T>::check_integrity() const {
-	time::time_t last_time = std::numeric_limits<time::time_t>::min();
+	time::time_t last_time = time::TIME_MIN;
 	for (const auto &keyframe : this->container) {
 		if (keyframe.time < last_time) {
 			throw Error{MSG(err) << "curve is broken after t=" << last_time << ": " << this->str()};

libopenage/curve/iterator.h

@@ -33,8 +33,8 @@ class CurveIterator {
 	explicit CurveIterator(const container_t *c) :
 		base{},
 		container{c},
-		from{-std::numeric_limits<time::time_t>::max()},
-		to{+std::numeric_limits<time::time_t>::max()} {}
+		from{-time::TIME_MAX},
+		to{+time::TIME_MAX} {}
 
 protected:
 	/**

libopenage/curve/keyframe.h

@@ -33,7 +33,7 @@ class Keyframe {
 		time{time},
 		value{value} {}
 
-	const time::time_t time = std::numeric_limits<time::time_t>::min();
+	const time::time_t time = time::TIME_MIN;
 	T value = T{};
 };
 

libopenage/curve/keyframe_container.h

@@ -281,7 +281,7 @@ class KeyframeContainer {
      *              the keyframes of \p other.
      */
 	iterator sync(const KeyframeContainer<T> &other,
-	              const time::time_t &start = std::numeric_limits<time::time_t>::min());
+	              const time::time_t &start = time::TIME_MIN);
 
 	/**
      * Copy keyframes from another container (with a different element type) to this container.
@@ -298,7 +298,7 @@ class KeyframeContainer {
 	template <typename O>
 	iterator sync(const KeyframeContainer<O> &other,
 	              const std::function<T(const O &)> &converter,
-	              const time::time_t &start = std::numeric_limits<time::time_t>::min());
+	              const time::time_t &start = time::TIME_MIN);
 
 	/**
 	 * Debugging method to be used from gdb to understand bugs better.
@@ -328,15 +328,15 @@ template <typename T>
 KeyframeContainer<T>::KeyframeContainer() {
 	// Create a default element at -Inf, that can always be dereferenced - so
 	// there will by definition never be a element that cannot be dereferenced
-	this->container.push_back(keyframe_t(std::numeric_limits<time::time_t>::min(), T()));
+	this->container.push_back(keyframe_t(time::TIME_MIN, T()));
 }
 
 
 template <typename T>
 KeyframeContainer<T>::KeyframeContainer(const T &defaultval) {
 	// Create a default element at -Inf, that can always be dereferenced - so
 	// there will by definition never be a element that cannot be dereferenced
-	this->container.push_back(keyframe_t(std::numeric_limits<time::time_t>::min(), defaultval));
+	this->container.push_back(keyframe_t(time::TIME_MIN, defaultval));
 }
 
 

libopenage/curve/map.h

@@ -48,10 +48,10 @@ class UnorderedMap {
 	at(const time::time_t &, const key_t &) const;
 
 	MapFilterIterator<key_t, val_t, UnorderedMap>
-	begin(const time::time_t &e = std::numeric_limits<time::time_t>::max()) const;
+	begin(const time::time_t &e = time::TIME_MAX) const;
 
 	MapFilterIterator<key_t, val_t, UnorderedMap>
-	end(const time::time_t &e = std::numeric_limits<time::time_t>::max()) const;
+	end(const time::time_t &e = time::TIME_MAX) const;
 
 	MapFilterIterator<key_t, val_t, UnorderedMap>
 	insert(const time::time_t &birth, const key_t &, const val_t &);
@@ -100,7 +100,7 @@ UnorderedMap<key_t, val_t>::at(const time::time_t &time,
 			e,
 			this,
 			time,
-			std::numeric_limits<time::time_t>::max());
+			time::TIME_MAX);
 	}
 	else {
 		return {};
@@ -114,7 +114,7 @@ UnorderedMap<key_t, val_t>::begin(const time::time_t &time) const {
 		this->container.begin(),
 		this,
 		time,
-		std::numeric_limits<time::time_t>::max());
+		time::TIME_MAX);
 }
 
 template <typename key_t, typename val_t>
@@ -123,7 +123,7 @@ UnorderedMap<key_t, val_t>::end(const time::time_t &time) const {
 	return MapFilterIterator<key_t, val_t, UnorderedMap<key_t, val_t>>(
 		this->container.end(),
 		this,
-		-std::numeric_limits<time::time_t>::max(),
+		-time::TIME_MAX,
 		time);
 }
 
@@ -149,7 +149,7 @@ UnorderedMap<key_t, val_t>::insert(const time::time_t &alive,
                                    const val_t &value) {
 	return this->insert(
 		alive,
-		std::numeric_limits<time::time_t>::max(),
+		time::TIME_MAX,
 		key,
 		value);
 }

libopenage/curve/queue.h

@@ -53,7 +53,7 @@ class Queue : public event::EventEntity {
 		EventEntity{loop},
 		_id{id},
 		_idstr{idstr},
-		last_front{this->container.begin()} {}
+		last_pop{time::TIME_ZERO} {}
 
 	// prevent accidental copy of queue
 	Queue(const Queue &) = delete;
@@ -69,12 +69,13 @@ class Queue : public event::EventEntity {
 	const T &front(const time::time_t &time) const;
 
 	/**
-	 * Get the first element in the queue at the given time.
+	 * Get the first element in the queue at the given time and remove it from
+     * the queue.
 	 *
 	 * @param time The time to get the element at.
 	 * @param value Queue element.
 	 */
-	const T &pop_front(const time::time_t &time);
+	const T pop_front(const time::time_t &time);
 
 	/**
 	 * Check if the queue is empty at a given time.
@@ -92,7 +93,7 @@ class Queue : public event::EventEntity {
 	 * @return Iterator to the first element.
 	 */
 	QueueFilterIterator<T, Queue<T>> begin(
-		const time::time_t &t = -std::numeric_limits<time::time_t>::max()) const;
+		const time::time_t &t = -time::TIME_MAX) const;
 
 	/**
 	 * Get an iterator to the last element in the queue at the given time.
@@ -101,7 +102,7 @@ class Queue : public event::EventEntity {
 	 * @return Iterator to the last element.
 	 */
 	QueueFilterIterator<T, Queue<T>> end(
-		const time::time_t &t = std::numeric_limits<time::time_t>::max()) const;
+		const time::time_t &t = time::TIME_MAX) const;
 
 	/**
 	 * Get an iterator to elements that are in the queue between two time frames.
@@ -111,8 +112,8 @@ class Queue : public event::EventEntity {
 	 * @return Iterator to the first element in the time frame.
 	 */
 	QueueFilterIterator<T, Queue<T>> between(
-		const time::time_t &begin = std::numeric_limits<time::time_t>::max(),
-		const time::time_t &end = std::numeric_limits<time::time_t>::max()) const;
+		const time::time_t &begin = time::TIME_MAX,
+		const time::time_t &end = time::TIME_MAX) const;
 
 	/**
 	 * Erase an element from the queue.
@@ -183,24 +184,72 @@ class Queue : public event::EventEntity {
 	 */
 	container_t container;
 
-	iterator last_front;
+	/**
+     * The time of the last access to the queue.
+     */
+	time::time_t last_pop;
 };
 
 
 template <typename T>
-const T &Queue<T>::front(const time::time_t &t) const {
-	return this->begin(t).value();
+const T &Queue<T>::front(const time::time_t &time) const {
+	if (this->empty(time)) [[unlikely]] {
+		throw Error{MSG(err) << "Tried accessing front at "
+		                     << time << " but queue is empty."};
+	}
+
+	// search for the last element before the given time
+	auto it = this->container.end();
+	--it;
+	while (it->time() > time and it != this->container.begin()) {
+		--it;
+	}
+
+	return it->value;
 }
 
 template <class T>
-bool Queue<T>::empty(const time::time_t &time) const {
-	return this->last_front == this->begin(time).get_base();
+const T Queue<T>::pop_front(const time::time_t &time) {
+	if (this->empty(time)) [[unlikely]] {
+		throw Error{MSG(err) << "Tried accessing front at "
+		                     << time << " but queue is empty."};
+	}
+
+	// search for the last element before the given time
+	auto it = this->container.end();
+	--it;
+	while (it->time() > time and it != this->container.begin()) {
+		--it;
+	}
+
+	// get the last element inserted before the given time
+	auto val = std::move(it->value);
+
+	// get the time span between current time and the next element
+	auto to = (++it)->time();
+	--it;
+	auto from = time;
+
+	// erase the element
+	// TODO: We should be able to reinsert elements
+	auto filter_iterator = QueueFilterIterator<T, Queue<T>>(it, this, to, from);
+	this->erase(filter_iterator);
+
+	this->last_pop = time;
+
+	return val;
 }
 
 template <class T>
-inline const T &Queue<T>::pop_front(const time::time_t &time) {
-	this->last_front = this->begin(time).get_base();
-	return this->front(time);
+bool Queue<T>::empty(const time::time_t &time) const {
+	if (this->container.empty()) {
+		return true;
+	}
+
+	// search for the first element that is after the given time
+	auto begin = this->begin(time).get_base();
+
+	return begin == this->container.begin() and begin->time() > time;
 }
 
 template <typename T>
@@ -211,7 +260,7 @@ QueueFilterIterator<T, Queue<T>> Queue<T>::begin(const time::time_t &t) const {
 				it,
 				this,
 				t,
-				std::numeric_limits<time::time_t>::max());
+				time::TIME_MAX);
 		}
 	}
 
@@ -225,20 +274,19 @@ QueueFilterIterator<T, Queue<T>> Queue<T>::end(const time::time_t &t) const {
 		container.end(),
 		this,
 		t,
-		std::numeric_limits<time::time_t>::max());
+		time::TIME_MAX);
 }
 
 
 template <typename T>
-QueueFilterIterator<T, Queue<T>> Queue<T>::between(
-	const time::time_t &begin,
-	const time::time_t &end) const {
+QueueFilterIterator<T, Queue<T>> Queue<T>::between(const time::time_t &begin,
+                                                   const time::time_t &end) const {
 	auto it = QueueFilterIterator<T, Queue<T>>(
 		container.begin(),
 		this,
 		begin,
 		end);
-	if (!container.empty() && !it.valid()) {
+	if (not it.valid()) {
 		++it;
 	}
 	return it;
@@ -253,9 +301,8 @@ void Queue<T>::erase(const CurveIterator<T, Queue<T>> &it) {
 
 
 template <typename T>
-QueueFilterIterator<T, Queue<T>> Queue<T>::insert(
-	const time::time_t &time,
-	const T &e) {
+QueueFilterIterator<T, Queue<T>> Queue<T>::insert(const time::time_t &time,
+                                                  const T &e) {
 	const_iterator insertion_point = this->container.end();
 	for (auto it = this->container.begin(); it != this->container.end(); ++it) {
 		if (time < it->time()) {
@@ -272,7 +319,7 @@ QueueFilterIterator<T, Queue<T>> Queue<T>::insert(
 		insertion_point,
 		this,
 		time,
-		std::numeric_limits<time::time_t>::max());
+		time::TIME_MAX);
 
 	if (!ct.valid()) {
 		++ct;

libopenage/curve/tests/container.cpp

@@ -149,11 +149,25 @@ void test_queue() {
 	auto loop = std::make_shared<event::EventLoop>();
 
 	Queue<int> q{loop, 0};
-	q.insert(0, 1);
+
+	TESTEQUALS(q.empty(0), true);
+	TESTEQUALS(q.empty(1), true);
+	TESTEQUALS(q.empty(100001), true);
+
 	q.insert(2, 2);
 	q.insert(4, 3);
 	q.insert(10, 4);
 	q.insert(100001, 5);
+	q.insert(100001, 6);
+
+	TESTEQUALS(q.empty(0), true);
+	TESTEQUALS(q.empty(1), true);
+	TESTEQUALS(q.empty(2), false);
+	TESTEQUALS(q.empty(100001), false);
+	TESTEQUALS(q.empty(100002), false);
+
+	q.insert(0, 1);
+
 	TESTEQUALS(*q.begin(0), 1);
 	TESTEQUALS(*q.begin(1), 2);
 	TESTEQUALS(*q.begin(2), 2);
@@ -164,6 +178,17 @@ void test_queue() {
 	TESTEQUALS(*q.begin(12), 5);
 	TESTEQUALS(*q.begin(100000), 5);
 
+	TESTEQUALS(q.front(0), 1);
+	TESTEQUALS(q.front(1), 1);
+	TESTEQUALS(q.front(2), 2);
+	TESTEQUALS(q.front(3), 2);
+	TESTEQUALS(q.front(4), 3);
+	TESTEQUALS(q.front(5), 3);
+	TESTEQUALS(q.front(10), 4);
+	TESTEQUALS(q.front(12), 4);
+	TESTEQUALS(q.front(100000), 4);
+	TESTEQUALS(q.front(100001), 6);
+
 	{
 		std::unordered_set<int> reference = {1, 2, 3};
 		for (auto it = q.between(0, 6); it != q.end(); ++it) {
@@ -204,6 +229,19 @@ void test_queue() {
 		}
 		TESTEQUALS(reference.empty(), true);
 	}
+
+
+	TESTEQUALS(q.pop_front(0), 1);
+	TESTEQUALS(q.empty(0), true);
+
+	TESTEQUALS(q.pop_front(12), 4);
+	TESTEQUALS(q.empty(12), false);
+
+	TESTEQUALS(q.pop_front(12), 3);
+	TESTEQUALS(q.empty(12), false);
+
+	TESTEQUALS(q.pop_front(12), 2);
+	TESTEQUALS(q.empty(12), true);
 }