Preserve insertion order in G3TimestreamMap

Use a custom OrderedMap class that behaves identically to std::map, except that
items are iterated over in the order they were inserted into the map.

This allows preserving the detector ordering when creating a G3TimestreamMap
from a 2D array and a set of keys, e.g. when converting between
G3SuperTimestream and G3TimestreamMap objects, as the former are not guaranteed
to be ordered alphabetically.

Author: arahlin

core/include/core/G3Timestream.h

@@ -5,7 +5,7 @@
 #include <G3TimeStamp.h>
 #include <G3Vector.h>
 #include <vector>
-#include <map>
+#include <containers.h>
 
 class G3Timestream : public G3FrameObject {
 public:
@@ -181,11 +181,13 @@ struct G3Timestream::TimeStreamTypeResolver<int64_t>{
 };
 
 class G3TimestreamMap : public G3FrameObject,
-    public std::map<std::string, G3TimestreamPtr> {
+    public OrderedMap<std::string, G3TimestreamPtr>{
 public:
 	G3TimestreamMap(){}
-	G3TimestreamMap(const G3TimestreamMap& other):std::map<std::string, G3TimestreamPtr>(other){}
-	G3TimestreamMap(G3TimestreamMap&& other):std::map<std::string, G3TimestreamPtr>(std::move(other)){}
+	G3TimestreamMap(const G3TimestreamMap& other) :
+	    OrderedMap<std::string, G3TimestreamPtr>(other) {}
+	G3TimestreamMap(G3TimestreamMap&& other) :
+	    OrderedMap<std::string, G3TimestreamPtr>(std::move(other)) {}
 
 	G3TimestreamMap& operator=(const G3TimestreamMap&)=default;
 	G3TimestreamMap& operator=(G3TimestreamMap&&)=default;
@@ -253,8 +255,6 @@ class G3TimestreamMap : public G3FrameObject,
 	void FromBuffer(const std::vector<std::string>& keys, std::size_t n_samples,
 	    std::shared_ptr<SampleType[]> data, G3Time start, G3Time stop,
 	    G3Timestream::TimestreamUnits units=G3Timestream::None, int compression_level=0) {
-		if(!std::is_sorted(keys.begin(), keys.end()))
-			throw std::runtime_error("G3TimestreamMap::MakeCompact: keys must be sorted");
 		const auto data_type=G3Timestream::TimeStreamTypeResolver<SampleType>::type_tag;
 		std::size_t offset = 0;
 		for (const auto& key : keys) {
@@ -267,7 +267,7 @@ class G3TimestreamMap : public G3FrameObject,
 			ts->data_ = data.get() + offset;
 			ts->data_type_ = data_type;
 			ts->len_ = n_samples;
-			emplace(key, std::move(ts));
+			insert({key, std::move(ts)});
 			offset += n_samples;
 		}
 	}
@@ -284,7 +284,7 @@ namespace cereal {
 }
 
 G3_SERIALIZABLE(G3Timestream, 3);
-G3_SERIALIZABLE(G3TimestreamMap, 3);
+G3_SERIALIZABLE(G3TimestreamMap, 4);
 
 #endif
 

core/include/core/containers.h

@@ -0,0 +1,172 @@
+#ifndef _G3_CONTAINERS_H
+#define _G3_CONTAINERS_H
+
+#include <vector>
+#include <unordered_map>
+#include <iterator>
+
+template <typename K, typename T>
+class OrderedMap {
+public:
+	using map_type = std::unordered_map<K, T>;
+	using key_map_type = std::vector<K>;
+	using key_type = K;
+	using mapped_type = T;
+	using value_type = typename map_type::value_type;
+	using difference_type = typename map_type::difference_type;
+	using size_type = typename map_type::size_type;
+
+	OrderedMap() {};
+	OrderedMap(const OrderedMap& other) :
+	    map_(other.map_), keys_(other.keys_) {}
+	OrderedMap(OrderedMap&& other) :
+	    map_(std::move(other.map_)), keys_(std::move(other.keys_)) {}
+	virtual ~OrderedMap() {};
+
+	OrderedMap& operator=(const OrderedMap&) = default;
+	OrderedMap& operator=(OrderedMap&&) = default;
+
+	mapped_type& operator[](const key_type& key) {
+		auto it = std::find(keys_.begin(), keys_.end(), key);
+		if (it == keys_.end())
+			keys_.push_back(key);
+		return map_[key];
+	}
+	const mapped_type& operator[](const key_type& key) const { return map_.at(key); }
+	mapped_type& at(const key_type& key) { return map_.at(key); }
+	const mapped_type& at(const key_type& key) const { return map_.at(key); }
+	bool contains(const key_type& key) const { return map_.count(key) > 0; }
+
+	size_type size() const { return map_.size(); }
+	size_type max_size() const { return map_.max_size(); }
+	bool empty() const { return map_.empty(); }
+
+	void clear() {
+		map_.clear();
+		keys_.clear();
+	}
+
+	size_type erase(const key_type& key) {
+		auto it = std::find(keys_.begin(), keys_.end(), key);
+		if (it == keys_.end())
+			return 0;
+
+		keys_.erase(it);
+		return map_.erase(key);
+	}
+
+	class iterator {
+	public:
+		using iterator_category = std::forward_iterator_tag;
+		using value_type = typename map_type::value_type;
+		using difference_type = typename map_type::difference_type;
+		using pointer = value_type*;
+		using reference = value_type&;
+
+		typename key_map_type::iterator cur;
+		map_type& map;
+
+		iterator(typename key_map_type::iterator it, map_type& map) :
+		    cur(it), map(map) {}
+
+		iterator& operator++() {
+			++cur;
+			return *this;
+		}
+
+		iterator operator++(int) {
+			iterator tmp = *this;
+			++(*this);
+			return tmp;
+		}
+
+		bool operator==(const iterator& other) const { return cur == other.cur; }
+		bool operator!=(const iterator& other) const { return cur != other.cur; }
+
+		pointer operator->() const { return &(*(map.find(*cur))); }
+		reference operator*() const { return *(map.find(*cur)); }
+	};
+
+	class const_iterator {
+	public:
+		using iterator_category = std::forward_iterator_tag;
+		using value_type = typename map_type::value_type;
+		using difference_type = typename map_type::difference_type;
+		using pointer = const value_type*;
+		using reference = const value_type&;
+
+		typename key_map_type::const_iterator cur;
+		const map_type& map;
+
+		const_iterator(typename key_map_type::const_iterator it,
+		    const map_type& map) : cur(it), map(map) {}
+
+		const_iterator(const iterator& other) : cur(other.cur), map(other.map) {}
+
+		const_iterator& operator++() {
+			++cur;
+			return *this;
+		}
+
+		const_iterator operator++(int) {
+			const_iterator tmp = *this;
+			++(*this);
+			return tmp;
+		}
+
+		bool operator==(const const_iterator& other) const { return cur == other.cur; }
+		bool operator!=(const const_iterator& other) const { return cur != other.cur; }
+
+		pointer operator->() const { return &(*(map.find(*cur))); }
+		reference operator*() const { return *(map.find(*cur)); }
+	};
+
+	iterator begin() { return iterator(keys_.begin(), map_); }
+	iterator end() { return iterator(keys_.end(), map_); }
+	const_iterator begin() const { return const_iterator(keys_.begin(), map_); }
+	const_iterator end() const { return const_iterator(keys_.end(), map_); }
+	const_iterator cbegin() const { return const_iterator(keys_.cbegin(), map_); }
+	const_iterator cend() const { return const_iterator(keys_.cend(), map_); }
+
+	iterator find(const key_type& key) {
+		return iterator(std::find(keys_.begin(), keys_.end(), key), map_);
+	}
+
+	const_iterator find(const key_type& key) const {
+		return const_iterator(std::find(keys_.cbegin(), keys_.cend(), key), map_);
+	}
+
+	std::pair<iterator, bool> insert(const value_type& pair) {
+		const key_type& key = pair.first;
+
+		bool check = false;
+		auto it = std::find(keys_.begin(), keys_.end(), key);
+		if (it == keys_.end()) {
+			keys_.push_back(key);
+			it = std::prev(keys_.end());
+			check = true;
+		}
+		map_.insert(pair);
+		return {iterator(it, map_), check};
+	}
+
+	std::pair<iterator, bool> insert(value_type&& pair) {
+		const key_type& key = pair.first;
+
+		bool check = false;
+		auto it = std::find(keys_.begin(), keys_.end(), key);
+		if (it == keys_.end()) {
+			keys_.push_back(key);
+			it = std::prev(keys_.end());
+			check = true;
+		}
+		map_.insert(pair);
+		return {iterator(it, map_), check};
+	}
+
+protected:
+	map_type map_;
+	key_map_type keys_;
+};
+
+#endif

core/src/G3Timestream.cxx

@@ -650,10 +650,14 @@ template <class A> void G3TimestreamMap::serialize(A &ar, unsigned v)
 			this->insert(std::pair<std::string, G3TimestreamPtr>(
 			    i->first, G3TimestreamPtr(new G3Timestream(
 			    i->second))));
+	} else if (v < 4) {
+		std::map<std::string, G3TimestreamPtr> oldmap;
+		ar & cereal::make_nvp("map", oldmap);
+		for (auto &it: oldmap)
+			this->insert(it);
 	} else {
-		ar & cereal::make_nvp("map",
-		    cereal::base_class<std::map<std::string,
-		    G3TimestreamPtr> >(this));
+		ar & cereal::make_nvp("map", map_);
+		ar & cereal::make_nvp("keys", keys_);
 	}
 	if (v < 2) {
 		// Load old timestreams with start/stop in the map instead of