Merge branch 'main' of https://github.com/Martian-Technologies/Connection-Machine

Author: ItchyTrack

src/backend/evaluator/evalDefs.h

@@ -27,6 +27,14 @@ struct SimulatorMappingUpdateListener {
 	std::function<void(const std::vector<SimulatorMappingUpdate>&)> callback;
 };
 
+enum class Direction {
+	IN,
+	OUT,
+};
+inline Direction operator!(Direction dir) {
+	return (dir == Direction::IN) ? Direction::OUT : Direction::IN;
+}
+
 class Evaluator;
 typedef std::shared_ptr<class Evaluator> SharedEvaluator;
 

src/backend/evaluator/evaluator.h

@@ -6,7 +6,6 @@
 #include "util/evalAddressTree.h"
 #include "util/evalConnection.h"
 #include "util/evalConfig.h"
-#include "util/directionEnum.h"
 #include "simulator/logicState.h"
 
 class DataUpdateEventManager;

src/backend/evaluator/evaluatorManager.h

@@ -2,7 +2,6 @@
 #define evaluatorManager_h
 
 #include "backend/circuit/circuit.h"
-#include "util/idProvider.h"
 #include "evalDefs.h"
 
 class CircuitManager;

src/backend/evaluator/layers/layer6_simulatorOptimizer.h

@@ -4,7 +4,6 @@
 #include "backend/evaluator/simulator/logicSimulator.h"
 #include "backend/evaluator/util/evalConnection.h"
 #include "backend/evaluator/util/evalConfig.h"
-#include "util/idProvider.h"
 
 class SimulatorOptimizer {
 public:

src/backend/evaluator/simulator/logicSimulator.h

@@ -5,7 +5,6 @@
 #include "backend/container/block/connectionEnd.h"
 #include "backend/evaluator/util/evalConfig.h"
 #include "backend/evaluator/evalDefs.h"
-#include "util/idProvider.h"
 #include "simulatorGates.h"
 #include "logicState.h"
 #include "threadPool.h"

src/backend/evaluator/simulator/simulatorGates.h

@@ -3,7 +3,6 @@
 
 #include "logicState.h"
 #include "backend/evaluator/evalDefs.h"
-#include "util/idVector.h"
 
 class SimulatorGate {
 public:

src/backend/evaluator/util/directionEnum.h

@@ -2,8 +2,6 @@
 #define evalCircuitContainer_h
 
 #include "backend/address.h"
-#include "util/idProvider.h"
-#include "util/idVector.h"
 #include "evalCircuit.h"
 
 struct EvalPosition {

src/backend/evaluator/util/evalCircuitContainer.h

@@ -3,7 +3,6 @@
 
 #include "backend/circuit/parsedCircuit.h"
 #include "backend/circuit/circuit.h"
-#include "util/idProvider.h"
 #include "parsedCircuitLoader.h"
 #include "circuitFileManager.h"
 

src/computerAPI/circuits/BLIFParser.h

@@ -117,4 +117,163 @@ struct id_traits<Id<Tag, Rep>> {
 template<class T>
 concept IdType = is_id_v<T>;
 
+template<IdType IdT>
+class IdProvider {
+public:
+	using id_type = std::remove_cv_t<IdT>;
+	using rep = typename id_traits<id_type>::rep;
+
+	constexpr IdProvider(rep initialValue) : nextId(initialValue) {}
+
+	constexpr id_type getNewId() {
+		if (unusedIds.empty()) {
+			return id_type(nextId++);
+		} else {
+			rep id = *unusedIds.begin();
+			unusedIds.erase(unusedIds.begin());
+			return id_type(id);
+		}
+	}
+	constexpr id_type getNewId(id_type preferredId) {
+		if (unusedIds.size() * 2 < nextId && unusedIds.contains(preferredId.get())) {
+			unusedIds.erase(preferredId.get());
+			return preferredId;
+		}
+		if (preferredId.get() == nextId || unusedIds.empty()) {
+			return id_type(nextId++);
+		} else {
+			rep id = *unusedIds.begin();
+			unusedIds.erase(unusedIds.begin());
+			return id_type(id);
+		}
+	}
+	constexpr void releaseId(id_type id) {
+		if (!isIdUsed(id)) {
+			return;
+		}
+		unusedIds.insert(id.get());
+	}
+	constexpr bool isIdUsed(id_type id) const {
+		return id.get() < nextId && !unusedIds.contains(id.get());
+	}
+	constexpr id_type peekNext() const {
+		return id_type(nextId);
+	}
+	void reset() {
+		nextId = 0;
+		unusedIds.clear();
+	}
+	std::vector<id_type> getUsedIds() const {
+		std::vector<id_type> usedIds;
+		for (rep id = 0; id < nextId; ++id) {
+			if (!unusedIds.contains(id)) {
+				usedIds.push_back(id_type(id));
+			}
+		}
+		return usedIds;
+	}
+private:
+	rep nextId;
+	std::set<rep> unusedIds;
+};
+
+template<IdType IdT>
+class LinearIdProvider {
+public:
+	using id_type = std::remove_cv_t<IdT>;
+	using rep = typename id_traits<id_type>::rep;
+
+	constexpr LinearIdProvider(rep initialValue) : nextId(initialValue) {}
+
+	constexpr id_type getNewId() {
+		return id_type(nextId++);
+	}
+	constexpr id_type peekNext() const {
+		return id_type(nextId);
+	}
+	constexpr id_type lastIdProvided() const {
+		return idType(nextId - 1);
+	}
+	void reset() {
+		nextId = 0;
+	}
+
+private:
+	rep nextId;
+};
+
+template<IdType IdT, class T>
+class IdVector {
+public:
+    using id_type = std::remove_cv_t<IdT>;
+    using tag = typename id_traits<id_type>::tag;
+    using rep = typename id_traits<id_type>::rep;
+    using value_type = T;
+
+    static_assert(std::is_integral_v<rep>, "Id::rep must be an integral type");
+
+    constexpr IdVector() = default;
+    explicit IdVector(id_type n)                  : storage_(rep(n)) {}
+    IdVector(id_type n, const T& value)           : storage_(rep(n), value) {}
+
+    inline id_type size() const noexcept                { return id_type{rep(storage_.size())}; }
+    inline bool    empty() const noexcept               { return storage_.empty(); }
+
+    inline id_type capacity() const noexcept            { return id_type{rep(storage_.capacity())}; }
+
+    inline void reserve(id_type n)                      { storage_.reserve(n.get()); }
+    inline void resize(id_type n)                       { storage_.resize(n.get()); }
+    inline void resize(id_type n, const T& value)       { storage_.resize(n.get(), value); }
+    inline void resizeWithOffset(id_type n, int offset) { storage_.resize(n.get() + offset); }
+    inline void resizeWithOffset(id_type n, int offset, const T& value) { storage_.resize(n.get() + offset, value); }
+
+    inline void clear() noexcept                        { storage_.clear(); }
+
+    inline T& operator[](id_type id)                    { return storage_[id.get()]; }
+    inline const T& operator[](id_type id) const        { return storage_[id.get()]; }
+
+    inline T& at(id_type id)                            { return storage_.at(id.get()); }
+    inline const T& at(id_type id) const                { return storage_.at(id.get()); }
+
+    inline id_type push_back(const T& v) {
+        storage_.push_back(v);
+        return last_id_();
+    }
+    inline id_type push_back(T&& v) {
+        storage_.push_back(std::move(v));
+        return last_id_();
+    }
+    template<class... Args>
+    inline id_type emplace_back(Args&&... args) {
+        storage_.emplace_back(std::forward<Args>(args)...);
+        return last_id_();
+    }
+
+    inline id_type begin_id() const noexcept { return id_type(0); }
+    inline id_type end_id()   const noexcept { return size(); }
+
+    inline bool contains(id_type id) const noexcept {
+        return id.get() < storage_.size();
+    }
+
+    inline IdRange<tag, rep> ids() const {
+        return range(begin_id(), end_id());
+    }
+
+    inline auto begin() noexcept { return storage_.begin(); }
+    inline auto end()   noexcept { return storage_.end(); }
+    inline auto begin() const noexcept { return storage_.begin(); }
+    inline auto end()   const noexcept { return storage_.end(); }
+    inline const std::vector<T>& raw() const noexcept { return storage_; }
+    inline std::vector<T>&       raw()       noexcept { return storage_; }
+
+private:
+    inline id_type last_id_() const {
+        auto n = storage_.size();
+        return id_type{rep(n - 1)};
+    }
+
+    std::vector<T> storage_;
+};
+
 #endif /* id_h */