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 in 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;
@@ -254,8 +256,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) {
@@ -268,7 +268,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;
 		}
 	}
@@ -285,7 +285,7 @@ namespace cereal {
 }
 
 G3_SERIALIZABLE(G3Timestream, 3);
-G3_SERIALIZABLE(G3TimestreamMap, 3);
+G3_SERIALIZABLE(G3TimestreamMap, 4);
 
 #endif
 

core/include/core/containers.h

@@ -0,0 +1,184 @@
+#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 = map_.find(key);
+		if (it == map_.end())
+			return 0;
+
+		map_.erase(it);
+
+		auto it_order = std::find(keys_.begin(), keys_.end(), key);
+		if (it_order != keys_.end())
+			keys_.erase(it_order);
+		return 1;
+	}
+
+	class const_iterator;
+
+	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; }
+		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)); }
+	};
+
+	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; }
+		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)); }
+	};
+
+	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) {
+		auto it = map_.find(key);
+		if (it == map_.end())
+			return end();
+		return iterator(std::find(keys_.begin(), keys_.end(), it->first), map_);
+	}
+
+	const_iterator find(const key_type& key) const {
+		auto it = map_.find(key);
+		if (it == map_.cend())
+			return cend();
+		return const_iterator(std::find(keys_.cbegin(), keys_.cend(), it->first), map_);
+	}
+
+	std::pair<iterator, bool> insert(const value_type& pair) {
+		const key_type& key = pair.first;
+
+		bool check = false;
+		if (map_.find(key) == map_.end()) {
+			keys_.push_back(key);
+			check = true;
+		}
+		map_.insert(pair);
+		return {iterator(std::find(keys_.begin(), keys_.end(), key), map_), check};
+	}
+
+	std::pair<iterator, bool> insert(value_type&& pair) {
+		const key_type& key = pair.first;
+
+		bool check = false;
+		if (map_.find(key) == map_.end()) {
+			keys_.push_back(key);
+			check = true;
+		}
+		map_.insert(pair);
+		return {iterator(std::find(keys_.begin(), keys_.end(), key), 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