Add circuit

Author: Glyphack

check.sh

@@ -2,8 +2,6 @@
 # This scripts runs various CI-like checks in a convenient way.
 set -eu
 
-rustup override set 1.89
-
 cargo check --quiet --workspace --all-targets
 cargo check --quiet --workspace --all-features --lib --target wasm32-unknown-unknown
 cargo fmt --all -- --check

src/app.rs

@@ -622,7 +622,6 @@ impl App {
     }
 
     pub fn delete_instance(&mut self, id: InstanceId) {
-        self.db.instances.remove(id);
         self.db.types.remove(id);
         self.db.gates.remove(id);
         self.db.powers.remove(id);

src/connection_manager.rs

@@ -124,7 +124,7 @@ impl ConnectionManager {
         self.pin_position_cache.clear();
 
         // Index all pins by their grid cell
-        for (instance_id, _) in &db.instances {
+        for (instance_id, _) in &db.types {
             for pin in db.pins_of(instance_id) {
                 let pos = db.pin_position(pin, &self.canvas_config);
                 let cell = GridCell::from_pos(pos);
@@ -292,7 +292,7 @@ impl ConnectionManager {
         pins_to_update.sort_unstable();
         pins_to_update.dedup();
 
-        if pins_to_update.len() > db.instances.len() / 4 {
+        if pins_to_update.len() > db.types.len() / 4 {
             self.rebuild_spatial_index(db);
         } else {
             self.update_spatial_index_for_pins(db, &pins_to_update);

src/db.rs

@@ -49,75 +49,70 @@ impl From<u32> for ModuleDefId {
     }
 }
 
+#[derive(Default, serde::Deserialize, serde::Serialize, Debug, Clone)]
+pub struct Circuit {}
+
 #[derive(Default, serde::Deserialize, serde::Serialize, Debug, Clone)]
 pub struct DB {
-    // Primary key allocator; ensures unique keys across all instance kinds
-    pub instances: SlotMap<InstanceId, ()>,
+    pub circuit: Circuit,
     // Type registry for each instance id
-    pub types: SecondaryMap<InstanceId, InstanceKind>,
+    pub types: SlotMap<InstanceId, InstanceKind>,
     // Per-kind payloads keyed off the primary key space
     pub gates: SecondaryMap<InstanceId, Gate>,
     pub powers: SecondaryMap<InstanceId, Power>,
     pub wires: SecondaryMap<InstanceId, Wire>,
     pub lamps: SecondaryMap<InstanceId, Lamp>,
     pub clocks: SecondaryMap<InstanceId, Clock>,
     pub modules: SecondaryMap<InstanceId, Module>,
-    // Definition of modules created by the user
-    pub module_definitions: SlotMap<ModuleDefId, ModuleDefinition>,
     pub connections: HashSet<Connection>,
     // Labels
     pub labels: SlotMap<LabelId, Label>,
+    // Definition of modules created by the user
+    pub module_definitions: SlotMap<ModuleDefId, ModuleDefinition>,
 }
 
 impl DB {
     pub fn new() -> Self {
         Self::default()
     }
     pub fn new_gate(&mut self, g: Gate) -> InstanceId {
-        let k = self.instances.insert(());
+        let k = self.types.insert(InstanceKind::Gate(g.kind));
         self.gates.insert(k, g);
         let kind = self
             .gates
             .get(k)
             .expect("gate must exist right after insertion")
             .kind;
-        self.types.insert(k, InstanceKind::Gate(kind));
         k
     }
 
     pub fn new_power(&mut self, p: Power) -> InstanceId {
-        let k = self.instances.insert(());
+        let k = self.types.insert(InstanceKind::Power);
         self.powers.insert(k, p);
-        self.types.insert(k, InstanceKind::Power);
         k
     }
 
     pub fn new_wire(&mut self, w: Wire) -> InstanceId {
-        let k = self.instances.insert(());
+        let k = self.types.insert(InstanceKind::Wire);
         self.wires.insert(k, w);
-        self.types.insert(k, InstanceKind::Wire);
         k
     }
 
     pub fn new_lamp(&mut self, l: Lamp) -> InstanceId {
-        let k = self.instances.insert(());
+        let k = self.types.insert(InstanceKind::Lamp);
         self.lamps.insert(k, l);
-        self.types.insert(k, InstanceKind::Lamp);
         k
     }
 
     pub fn new_clock(&mut self, c: Clock) -> InstanceId {
-        let k = self.instances.insert(());
+        let k = self.types.insert(InstanceKind::Clock);
         self.clocks.insert(k, c);
-        self.types.insert(k, InstanceKind::Clock);
         k
     }
 
     pub fn new_module(&mut self, c: crate::module::Module) -> InstanceId {
-        let k = self.instances.insert(());
-        let definition_index = c.definition_index;
+        let k = self.types.insert(InstanceKind::Module(c.definition_index));
         self.modules.insert(k, c);
-        self.types.insert(k, InstanceKind::Module(definition_index));
         k
     }