Merge branch 'main' of https://github.com/Martian-Technologies/Logic-Graph-Creator

Author: NicholasCiuica

src/backend/backend.cpp

@@ -1,6 +1,6 @@
 #include "backend.h"
 
-circuit_id_t Backend::createCircuit() { return circuitManager.createNewCircuit(); }
+circuit_id_t Backend::createCircuit(const std::string& uuid, const std::string& name) { return circuitManager.createNewCircuit(uuid, name); }
 
 std::optional<evaluator_id_t> Backend::createEvaluator(circuit_id_t circuitId) {
 	SharedCircuit circuit = circuitManager.getCircuit(circuitId);

src/backend/backend.h

@@ -5,13 +5,14 @@
 #include "evaluator/evaluatorManager.h"
 #include "circuit/circuitManager.h"
 #include "tools/toolManagerManager.h"
+#include "util/uuid.h"
 
 class Backend {
 public:
 	Backend() : toolManagerManager(&circuitViews) {}
 
 	// Creates a new Circuit. Returns circuit_id_t.
-	circuit_id_t createCircuit();
+	circuit_id_t createCircuit(const std::string& uuid = generate_uuid_v4(), const std::string& name = "Circuit");
 	// Attempts to create a Evaluator for a Circuit. Returns evaluator_id_t if successful.
 	std::optional<evaluator_id_t> createEvaluator(circuit_id_t circuitId);
 

src/backend/circuit/circuit.h

@@ -14,10 +14,13 @@ typedef unsigned int circuit_update_count;
 
 class Circuit {
 public:
-	inline Circuit(circuit_id_t circuitId, BlockDataManager* blockDataManager ) : circuitId(circuitId), blockContainer(blockDataManager) { }
+	inline Circuit(circuit_id_t circuitId, BlockDataManager* blockDataManager, const std::string& uuid, const std::string& name) :
+        circuitId(circuitId), blockContainer(blockDataManager), circuitUUID(uuid), circuitName(name) { }
 
+	inline const std::string& getUUID() const { return circuitUUID; }
 	inline circuit_id_t getCircuitId() const { return circuitId; }
-	inline std::string getCircuitName() const { return "Circuit " + std::to_string(circuitId); }
+	inline std::string getCircuitNameNumber() const { return circuitName + " : " + std::to_string(circuitId); }
+	inline const std::string& getCircuitName() const { return circuitName; }
 
     inline bool isSaved() const { return saved; }
     inline void setSaved() { saved = true; }
@@ -102,6 +105,8 @@ class Circuit {
 
 	void sendDifference(DifferenceSharedPtr difference) { if (difference->empty()) return; saved = false; if (!midUndo) undoSystem.addDifference(difference); for (auto pair : listenerFunctions) pair.second(difference, circuitId); }
 
+    std::string circuitName;
+    std::string circuitUUID;
 	circuit_id_t circuitId;
 	BlockContainer blockContainer;
 	CircuitBlockData circuitBlockData;

src/backend/circuit/circuitManager.h

@@ -18,9 +18,9 @@ class CircuitManager {
 		return iter->second;
 	}
 
-	inline circuit_id_t createNewCircuit() {
+	inline circuit_id_t createNewCircuit(const std::string& uuid, const std::string& name) {
 		circuit_id_t id = getNewCircuitId();
-		circuits.emplace(id, std::make_shared<Circuit>(id, &blockDataManager));
+		circuits.emplace(id, std::make_shared<Circuit>(id, &blockDataManager, uuid, name));
 		return id;
 	}
 

src/backend/circuit/parsedCircuit.h

@@ -81,6 +81,19 @@ class ParsedCircuit {
     void setFilePath(const std::string& fpath) { fullFilePath = fpath; }
     const std::string& getFilePath() const { return fullFilePath; }
 
+    void setName(const std::string& name) { importedCircuitName = name; }
+    const std::string& getName() const { return importedCircuitName; }
+
+    void setUUID(const std::string& uuid) { uuidFromLoad = uuid; }
+    const std::string& getUUID() const { return uuidFromLoad; }
+
+    void addCircuitNameUUID(const std::string& name, const std::string& uuid) {
+        circuitNameToUUID[name] = uuid;
+    }
+    const std::unordered_map<std::string, std::string>& getCircuitNameToUUID() const {
+        return circuitNameToUUID;
+    }
+
     bool isValid() const { return valid; }
     const Vector& getMinPos() const { return minPos; }
 
@@ -98,9 +111,14 @@ class ParsedCircuit {
 private:
     Vector minPos = Vector(std::numeric_limits<int>::max(), std::numeric_limits<int>::max());
     Vector maxPos = Vector(std::numeric_limits<int>::min(), std::numeric_limits<int>::min());
+
     std::unordered_map<block_id_t, BlockData> blocks;
     std::vector<ConnectionData> connections;
+
     std::string fullFilePath;
+    std::string uuidFromLoad;
+    std::string importedCircuitName;
+    std::unordered_map<std::string, std::string> circuitNameToUUID;
     bool valid = true;
 
     std::unordered_map<std::string, SharedParsedCircuit> dependencies;

src/backend/circuit/validateCircuit.cpp

@@ -123,10 +123,40 @@ bool CircuitValidator::setOverlapsUnpositioned() {
     return true;
 }
 
+
+// iterative dfs
+template <class PreVisit, class PostVisit>
+void depthFirstSearch(const std::unordered_map<block_id_t, std::vector<block_id_t>>& adj, block_id_t start, std::unordered_set<block_id_t>& visited, PreVisit preVisit, PostVisit postVisit) {
+    std::stack<block_id_t> stack;
+    stack.push(start);
+    visited.insert(start);
+    preVisit(start);
+    while (!stack.empty()) {
+        block_id_t node = stack.top();
+        bool hasUnvisited = false;
+        if (adj.count(node)){
+            for (block_id_t neighbor : adj.at(node)) {
+                if (visited.count(neighbor)) continue;
+                visited.insert(neighbor);
+                preVisit(neighbor);
+                stack.push(neighbor);
+                hasUnvisited = true;
+                break;
+            }
+        }
+
+        if (!hasUnvisited) {
+            stack.pop();
+            postVisit(node);
+        }
+    }
+}
+
 // SCC META GRAPH TOPOLOGICAL SORT
 bool CircuitValidator::handleUnpositionedBlocks() {
     // Separate components so that we can place down disconnected components independently
     std::unordered_map<block_id_t, std::vector<block_id_t>> undirectedAdj;
+    undirectedAdj.reserve(parsedCircuit.blocks.size());
     for (const ParsedCircuit::ConnectionData& conn : parsedCircuit.connections) {
         block_id_t u = conn.inputBlockId;
         block_id_t v = conn.outputBlockId;
@@ -136,94 +166,64 @@ bool CircuitValidator::handleUnpositionedBlocks() {
 
     // find cc's by dfs
     std::vector<std::unordered_set<block_id_t>> components;
+    std::unordered_map<block_id_t, int> blockToComponent;
     std::unordered_set<block_id_t> visited;
-    std::function<void(block_id_t)> dfsComponent = [&](block_id_t node) {
-        visited.insert(node);
-        components.back().insert(node);
-        for (block_id_t neighbor : undirectedAdj[node]) {
-            if (!visited.count(neighbor)) {
-                dfsComponent(neighbor);
-            }
-        }
-    };
     for (const auto& [id, block] : parsedCircuit.blocks) {
         if (!visited.count(id)) {
             components.push_back({});
-            dfsComponent(id);
+            depthFirstSearch(undirectedAdj, id, visited, [&](block_id_t node){components.back().insert(node); blockToComponent[node] = components.size()-1;}, [&](block_id_t){});
         }
     }
 
-    const int componentSpacing = 5;
-    int currentYOffset = 0;
-    int ccIndex = 0;
-    for (const std::unordered_set<block_id_t>& cc: components){
-        logInfo("Parsing CC " + std::to_string(++ccIndex));
-
-        // adjacency list
-        std::unordered_map<block_id_t, std::vector<block_id_t>> adj;
-        for (const auto& conn : parsedCircuit.connections) {
-            if (cc.count(conn.inputBlockId) && cc.count(conn.outputBlockId)) {
-                block_id_t to = conn.outputBlockId;
-                block_id_t from = conn.inputBlockId;
-                //logInfo("From: " + std::to_string(from) + "("+std::to_string(conn.outputId)+")" + 
-                //        ", To: " + std::to_string(to) + "("+std::to_string(conn.inputId)+")");
-                if (blockDataManager->isConnectionInput(parsedCircuit.blocks.at(conn.outputBlockId).type, conn.outputId)){
-                    adj[from].push_back(to);
-                }
-            }
+    // preprocess connected component connections
+    std::vector<std::unordered_map<block_id_t,std::vector<block_id_t>>> componentAdjs(components.size());
+    for (const ParsedCircuit::ConnectionData& conn : parsedCircuit.connections) {
+        if (blockDataManager->isConnectionInput(parsedCircuit.blocks.at(conn.outputBlockId).type,conn.outputId)){
+            int cc = blockToComponent[conn.inputBlockId];
+            componentAdjs[cc][conn.inputBlockId].push_back(conn.outputBlockId);
         }
+    }
 
-        // find SCC metagraph DAG for topological sort using kosaraju's
-        std::unordered_map<block_id_t, std::vector<block_id_t>> revAdj;
-        std::stack<block_id_t> postNumber; // highest post number node is a part of a source SCC, run on G^R
-        std::vector<std::vector<block_id_t>> sccs;
+    // precompute input connections for each block for layer placement
+    std::unordered_map<block_id_t, std::vector<block_id_t>> inputConnections;
+    for (const auto& conn : parsedCircuit.connections) {
+        inputConnections[conn.inputBlockId].push_back(conn.outputBlockId);
+    }
 
-        std::function<void(block_id_t)> dfs =
-            [&](block_id_t node) -> void {
-                visited.insert(node);
-                for (block_id_t v : adj[node]) {
-                    if (!visited.count(v)) {
-                        dfs(v);
-                    }
-                }
-                postNumber.push(node); // post visit
-            };
-
-        std::function<void(block_id_t, std::vector<block_id_t>&)> dfsRev =
-            [&](block_id_t node, std::vector<block_id_t>& component) -> void {
-                visited.insert(node);
-                component.push_back(node);
-                for (block_id_t v : revAdj[node]) {
-                    if (!visited.count(v)) {
-                        dfsRev(v, component);
-                    }
-                }
-            };
+    const int componentSpacing = 5;
+    int currentYOffset = 0;
+    for (int ccIndex=0; ccIndex<componentAdjs.size(); ++ccIndex){
+        const std::unordered_map<block_id_t, std::vector<block_id_t>>& adj = componentAdjs[ccIndex];
+        logInfo("Parsing CC " + std::to_string(ccIndex));
 
+        // find SCC metagraph DAG for topological sort using kosaraju's
         // gather stack that shows decreasing post visit numbers
+        std::stack<block_id_t> postNumber; // highest post number node is a part of a source SCC, run on G^R
         visited.clear();
-        for (block_id_t id : cc) {
+        for (block_id_t id : components[ccIndex]) {
             if (!visited.count(id)) {
-                dfs(id);
+                depthFirstSearch(adj, id, visited, [&](block_id_t){}, [&](block_id_t node){postNumber.push(node);});
             }
         }
 
         // make reverse graph in adjacency list
+        std::unordered_map<block_id_t, std::vector<block_id_t>> revAdj;
         for (const auto& [u, adjs] : adj) {
             for (block_id_t v : adjs) {
                 revAdj[v].push_back(u);
             }
         }
 
         // run dfs from source SCC's in reverse graph, sink SCCs of regular
+        std::vector<std::vector<block_id_t>> sccs;
         visited.clear();
         while (!postNumber.empty()) {
             block_id_t node = postNumber.top();
             postNumber.pop();
             if (!visited.count(node)) {
-                std::vector<block_id_t> component;
-                dfsRev(node, component);
-                sccs.push_back(component);
+                std::vector<block_id_t> revCC;
+                depthFirstSearch(adj, node, visited, [&](block_id_t node){revCC.push_back(node);}, [&](block_id_t){});
+                sccs.push_back(revCC);
             }
         }
 
@@ -275,12 +275,13 @@ bool CircuitValidator::handleUnpositionedBlocks() {
         }
 
         std::unordered_map<block_id_t, int> layers;
-        for (int sccIndex : sccOrder) {
-            for (block_id_t id : sccs[sccIndex]) {
+        for (int sccIdx : sccOrder) {
+            for (block_id_t id : sccs[sccIdx]) {
                 int maxLayer = 0;
-                for (const auto& conn : parsedCircuit.connections) {
-                    if (conn.inputBlockId == id) {
-                        maxLayer = std::max(maxLayer, layers[conn.outputBlockId] + 1);
+                auto it = inputConnections.find(id);
+                if (it != inputConnections.end()) {
+                    for (block_id_t outputBlock : it->second) {
+                        maxLayer = std::max(maxLayer, layers[outputBlock] + 1);
                     }
                 }
                 layers[id] = maxLayer;

src/backend/circuit/validateCircuit.h

@@ -1,8 +1,7 @@
 #ifndef validateCircuit_h
 #define validateCircuit_h
 #include "backend/circuit/parsedCircuit.h"
-#include "backend/circuit/circuit.h"
-#include <vector>
+#include "backend/container/block/blockDataManager.h"
 
 // Will take in a ParsedCircuit and modify its "valid" state to whether or not it is valid.
 // The parsed circuit is only considered to be valid or invalid relative to itself,