SequentialMap::erase, insert, find const, and make interface closer to std::map

Author: danngreen

tests/sequential_map_tests.cc

@@ -0,0 +1,98 @@
+#include "doctest.h"
+#include "util/sequential_map.hh"
+
+TEST_CASE("Basic use") {
+
+	SequentialMap<int, float, 4> sm;
+
+	// Pre-conditions:
+	CHECK(sm.size() == 0);
+	CHECK(sm.is_full() == false);
+
+	// Add a value
+	sm[2] = 3.f;
+	CHECK(sm.size() == 1);
+	CHECK(sm.is_full() == false);
+	CHECK(sm.contains(2));
+	CHECK(sm[2] == 3.f);
+
+	sm[9] = 99.f;
+	CHECK(sm.size() == 2);
+	CHECK(sm.is_full() == false);
+	CHECK(sm.contains(9));
+	CHECK(sm[9] == 99.f);
+
+	// Change a value
+	sm[2] = 5.f;
+	CHECK(sm.size() == 2);
+	CHECK(sm.is_full() == false);
+	CHECK(sm.contains(2));
+	CHECK(sm[2] == 5.f);
+
+	// Fill it up
+	sm[20] = 20.20f;
+	CHECK(sm.size() == 3);
+	CHECK(sm.is_full() == false);
+
+	sm[30] = 30.30f;
+	CHECK(sm.size() == 4);
+	CHECK(sm.is_full() == true);
+
+	// Overflow is handled by overwriting the last value added
+	CHECK(sm.contains(30));
+	sm[99] = 10.010f;
+	CHECK_FALSE(sm.contains(30));
+	CHECK(sm.contains(99));
+}
+
+TEST_CASE("Erase") {
+	SequentialMap<char, unsigned, 4> sm;
+
+	sm['a'] = 1;
+	sm['b'] = 10;
+	sm['c'] = 100;
+	sm['d'] = 1000;
+
+	auto it_b = sm.find('b');
+
+	SUBCASE("Erase first") {
+		CHECK(sm.erase('a') == 1);
+		CHECK(sm.size() == 3);
+		CHECK(sm.contains('a') == false);
+		CHECK(sm.contains('b') == true);
+		CHECK(sm.contains('c') == true);
+		CHECK(sm.contains('d') == true);
+
+		// Iterator is now invalid!
+		// This breaks with std::map
+		CHECK_FALSE(it_b->first == 'b');
+		CHECK_FALSE(it_b->second == 10);
+	}
+
+	SUBCASE("Erase middle") {
+		CHECK(sm.erase('b') == 1);
+		CHECK(sm.size() == 3);
+		CHECK(sm.contains('a') == true);
+		CHECK(sm.contains('b') == false);
+		CHECK(sm.contains('c') == true);
+		CHECK(sm.contains('d') == true);
+	}
+
+	SUBCASE("Erase last") {
+		CHECK(sm.erase('d') == 1);
+		CHECK(sm.size() == 3);
+		CHECK(sm.contains('a') == true);
+		CHECK(sm.contains('b') == true);
+		CHECK(sm.contains('c') == true);
+		CHECK(sm.contains('d') == false);
+
+		// Iterator is still valid
+		CHECK(it_b->first == 'b');
+		CHECK(it_b->second == 10);
+	}
+
+	// Can still add a new one
+	sm['e'] = 10000;
+	CHECK(sm.contains('e'));
+	CHECK(sm['e'] == 10000);
+}

util/fixed_vector.hh

@@ -77,7 +77,7 @@ public:
 		return back_idx;
 	}
 
-	constexpr size_t max_size() {
+	constexpr size_t max_size() const {
 		return MaxElements;
 	}
 
@@ -129,6 +129,8 @@ public:
 		back_idx -= count;
 	}
 
+	using iterator = decltype(data)::iterator;
+
 	auto begin() const {
 		return data.begin();
 	}

util/sequential_map.hh

@@ -1,12 +1,11 @@
 #pragma once
 #include "util/fixed_vector.hh"
-#include <type_traits>
 
 template<typename KeyT, typename ValT, size_t N>
 class SequentialMap {
 public:
 	struct PairT {
-		KeyT key;
+		KeyT first;
 		ValT second;
 	};
 
@@ -15,54 +14,105 @@ public:
 
 	const ValT &operator[](const KeyT key) const {
 		for (auto &pair : data) {
-			if (pair.key == key)
+			if (pair.first == key)
 				return pair.second;
 		}
 		return ValT{};
 	}
 
 	ValT &operator[](const KeyT key) {
 		for (auto &pair : data) {
-			if (pair.key == key)
+			if (pair.first == key) {
 				return pair.second;
+			}
 		}
 
 		auto newsize = data.push_back_for_overwrite();
 		if (newsize == data.max_size()) {
 			// Overflow: silently return last element
 			newsize--;
 		}
+		data[newsize].first = key;
 		return data[newsize].second;
 	}
 
+	// TODO: unit tests for this
+	std::pair<typename DataT::iterator, bool> insert(const PairT &entry) {
+		for (auto it = data.begin(); it < data.end(); it++) {
+			if (it->first == entry.first) {
+				return {it, false};
+			}
+		}
+
+		auto newsize = data.push_back_for_overwrite();
+		if (newsize == data.max_size()) {
+			return {data.end(), false};
+		}
+
+		data[newsize].first = entry.first;
+		return {data.end() - 1, true};
+	}
+
+	size_t size() const {
+		return data.size();
+	}
+
+	size_t max_size() const {
+		return data.max_size();
+	}
+
 	void clear() {
 		data.clear();
 	}
 
+	bool empty() const {
+		return data.size() == 0;
+	}
+
 	bool is_full() const {
 		return data.size() == data.max_size();
 	}
 
-	auto find(KeyT key) {
+	// TODO: unit tests for this
+	auto find(const KeyT &key) {
+		for (auto it = data.begin(); it < data.end(); it++) {
+			if (it->first == key)
+				return it;
+		}
+		return data.end();
+	}
+
+	// TODO: unit tests for this
+	auto find(const KeyT &key) const {
 		for (auto it = data.begin(); it < data.end(); it++) {
-			if (it->key == key)
+			if (it->first == key)
 				return it;
 		}
 		return data.end();
 	}
 
-	bool exists(const KeyT key) const {
+	// Unlike std::map, this will invalidate iterators
+	// to elements before the erased element
+	size_t erase(const KeyT &key) {
+		if (auto it = find(key); it != data.end()) {
+			data.erase(it, it + 1);
+			return 1;
+		}
+		return 0;
+	}
+
+	bool contains(const KeyT &key) const {
 		for (auto &pair : data) {
-			if (pair.key == key)
+			if (pair.first == key)
 				return true;
 		}
 		return false;
 	}
 
-	const auto begin() const {
+	auto begin() const {
 		return data.begin();
 	}
-	const auto end() const {
+	auto end() const {
 		return data.end();
 	}