Basic refactor

comdel/domain/address_space.cpp

@@ -0,0 +1,29 @@
+#include <algorithm>
+#include "address_space.h"
+
+namespace domain {
+
+    AddressSpace::AddressSpace(std::string name, long long start, long long end) :
+            name(name), start(start), end(end) {}
+
+    std::string AddressSpace::getName() {
+        return name;
+    }
+
+    long long AddressSpace::getStart() const {
+        return start;
+    }
+
+    long long AddressSpace::getEnd() const {
+        return end;
+    }
+
+    bool AddressSpace::contains(long long int address) {
+        return address >= start && address < end;
+    }
+
+    bool AddressSpace::contains(long long int pstart, long long int pend) {
+        return pstart >= start && pend < end;
+    }
+
+} // namespace domain

comdel/domain/address_space.h

@@ -0,0 +1,29 @@
+#ifndef DOMAIN_ADDRESS_SPACE_H
+#define DOMAIN_ADDRESS_SPACE_H
+
+#include <string>
+
+namespace domain {
+
+    class AddressSpace {
+        std::string name;
+        long long start;
+        long long end;
+
+    public:
+        AddressSpace(std::string name, long long start, long long end);
+
+        std::string getName();
+
+        long long getStart() const;
+
+        long long getEnd() const;
+
+        bool contains(long long int address);
+
+        bool contains(long long int start, long long int end);
+    };
+
+} // namespace domain
+
+#endif // DOMAIN_ADDRESS_SPACE_H

comdel/domain/addressspace.cpp

@@ -1,28 +0,0 @@
-#include <algorithm>
-#include "addressspace.h"
-
-namespace domain {
-
-AddressSpace::AddressSpace(std::string name, long long start, long long end):
-    name(name), start(start), end(end)
-{}
-
-std::string AddressSpace::getName() {
-    return name;
-}
-long long AddressSpace::getStart() const {
-    return start;
-}
-long long AddressSpace::getEnd() const {
-    return end;
-}
-
-bool AddressSpace::contains(long long int address) {
-    return address >= start && address < end;
-}
-
-bool AddressSpace::contains(long long int pstart, long long int pend) {
-    return pstart >= start && pend < end;
-}
-
-} // namespace domain

comdel/domain/addressspace.h

@@ -1,27 +0,0 @@
-#ifndef DOMAIN_ADDRESS_SPACE_H
-#define DOMAIN_ADDRESS_SPACE_H
-
-#include <string>
-
-namespace domain {
-
-class AddressSpace
-{
-    std::string name;
-    long long start;
-    long long end;
-
-public:
-    AddressSpace(std::string name, long long start, long long end);
-
-    std::string getName();
-    long long getStart() const;
-    long long getEnd() const;
-
-    bool contains(long long int address);
-    bool contains(long long int start, long long int end);
-};
-
-} // namespace domain
-
-#endif // DOMAIN_ADDRESS_SPACE_H

comdel/domain/attribute.cpp

@@ -2,55 +2,61 @@
 
 namespace domain {
 
-Enumeration::Enumeration(std::string name, Value value)
-    : name(name), value(value)
-{}
+    Enumeration::Enumeration(std::string name, Value value)
+            : name(name), value(value) {}
 
-std::string& Enumeration::getName() {
-    return name;
-}
-Value Enumeration::getValue() {
-    return value;
-}
+    std::string &Enumeration::getName() {
+        return name;
+    }
+
+    Value Enumeration::getValue() {
+        return value;
+    }
 
 
-Popup::Popup(std::string title, std::string text, PopupType type, std::vector<Rule> rules, std::vector<Enumeration> enumeration)
-    : title(title), text(text), type(type), rules(rules), enumerated(enumeration.size() > 0), enumeration(enumeration)
-{}
+    Popup::Popup(std::string title, std::string text, PopupType type, std::vector<Rule> rules,
+                 std::vector<Enumeration> enumeration)
+            : title(title), text(text), type(type), rules(rules), enumerated(enumeration.size() > 0),
+              enumeration(enumeration) {}
 
-std::string Popup::getTitle() {
-    return title;
-}
-std::string Popup::getText() {
-    return text;
-}
-Popup::PopupType Popup::getType() {
-    return type;
-}
-std::vector<Rule> Popup::getRules() {
-    return rules;
-}
+    std::string Popup::getTitle() {
+        return title;
+    }
 
-bool Popup::isEnumerated() {
-    return enumerated;
-}
-std::vector<Enumeration> &Popup::getEnumeration() {
-    return enumeration;
-}
+    std::string Popup::getText() {
+        return text;
+    }
+
+    Popup::PopupType Popup::getType() {
+        return type;
+    }
+
+    std::vector<Rule> Popup::getRules() {
+        return rules;
+    }
+
+    bool Popup::isEnumerated() {
+        return enumerated;
+    }
+
+    std::vector<Enumeration> &Popup::getEnumeration() {
+        return enumeration;
+    }
 
 
-Attribute::Attribute(std::string name, Value defaultValue, std::optional<Popup> popup)
-    : name(name), defaultValue(defaultValue), popup(popup)
-{}
+    Attribute::Attribute(std::string name, Value defaultValue, std::optional<Popup> popup)
+            : name(name), defaultValue(defaultValue), popup(popup) {}
 
-std::string Attribute::getName() {
-    return name;
-}
-Value Attribute::getDefault() {
-    return defaultValue;
-}
-std::optional<Popup> Attribute::getPopup() {
-    return popup;
-}
+    std::string Attribute::getName() {
+        return name;
+    }
+
+    Value Attribute::getDefault() {
+        return defaultValue;
+    }
+
+    std::optional<Popup> Attribute::getPopup() {
+        return popup;
+    }
 
 } // namespace domain

comdel/domain/attribute.h

@@ -9,62 +9,69 @@
 
 namespace domain {
 
-class Enumeration {
-    std::string name;
-    Value value;
-public:
-    Enumeration(std::string name, Value value);
+    class Enumeration {
+        std::string name;
+        Value value;
+    public:
+        Enumeration(std::string name, Value value);
 
-    std::string& getName();
-    Value getValue();
-};
+        std::string &getName();
 
-class Popup {
-public:
-    enum PopupType {
-        AUTOMATIC,
-        ON_DEMAND
+        Value getValue();
     };
 
-private:
-    std::string title;
-    std::string text;
-    PopupType type;
+    class Popup {
+    public:
+        enum PopupType {
+            AUTOMATIC,
+            ON_DEMAND
+        };
 
-    bool enumerated;
-    std::vector<Enumeration> enumeration;
-    std::vector<Rule> rules;
+    private:
+        std::string title;
+        std::string text;
+        PopupType type;
 
-public:
-    Popup(std::string title, std::string text, PopupType type, std::vector<Rule> rules, std::vector<Enumeration> enumeration);
+        bool enumerated;
+        std::vector<Enumeration> enumeration;
+        std::vector<Rule> rules;
 
-    std::string getTitle();
-    std::string getText();
-    PopupType getType();
-    std::vector<Rule> getRules();
+    public:
+        Popup(std::string title, std::string text, PopupType type, std::vector<Rule> rules,
+              std::vector<Enumeration> enumeration);
 
-    bool isEnumerated();
-    std::vector<Enumeration> &getEnumeration();
+        std::string getTitle();
 
-    void setEnumeration(std::vector<Enumeration> enums) {
-        enumerated = true;
-        enumeration = std::move(enums);
-    }
+        std::string getText();
 
-};
+        PopupType getType();
 
-class Attribute
-{
-    std::string name;
-    Value defaultValue;
-    std::optional<Popup> popup;
-public:
-    Attribute(std::string name, Value defaultValue, std::optional<Popup> popup = std::nullopt);
+        std::vector<Rule> getRules();
 
-    std::string getName();
-    Value getDefault();
-    std::optional<Popup> getPopup();
-};
+        bool isEnumerated();
+
+        std::vector<Enumeration> &getEnumeration();
+
+        void setEnumeration(std::vector<Enumeration> enums) {
+            enumerated = true;
+            enumeration = std::move(enums);
+        }
+
+    };
+
+    class Attribute {
+        std::string name;
+        Value defaultValue;
+        std::optional<Popup> popup;
+    public:
+        Attribute(std::string name, Value defaultValue, std::optional<Popup> popup = std::nullopt);
+
+        std::string getName();
+
+        Value getDefault();
+
+        std::optional<Popup> getPopup();
+    };
 
 } // namespace domain
 

comdel/domain/bus.cpp

@@ -2,51 +2,60 @@
 
 namespace domain {
 
-Wire::Wire(std::string name, WireType type, int width, bool hidden, bool hasTerminate, Value terminateWith)
-    : name(name), type(type), width(width), hidden(hidden), hasTerminate(hasTerminate), terminateWith(terminateWith)
-{}
+    Wire::Wire(std::string name, WireType type, int width, bool hidden, bool hasTerminate, Value terminateWith)
+            : name(name), type(type), width(width), hidden(hidden), hasTerminate(hasTerminate),
+              terminateWith(terminateWith) {}
 
-std::string Wire::getName() {
-    return name;
-}
-int Wire::getWidth() {
-    return width;
-}
-bool Wire::isHidden() {
-    return hidden;
-}
+    std::string Wire::getName() {
+        return name;
+    }
 
-bool Wire::hasTerminateWith() {
-    return hasTerminate;
-}
-Value Wire::getTerminateWith() {
-    return terminateWith;
-}
-Wire::WireType Wire::getType() {
-    return type;
-}
+    int Wire::getWidth() {
+        return width;
+    }
 
-Bus::Bus(std::string name, std::string tooltip, BusType type, std::pair<int, int> count, std::vector<Wire> wires, std::optional<ui::Bus> displayBus)
-    : name(name), tooltip(tooltip), type(type), count(count), wires(wires), displayBus(displayBus)
-{}
+    bool Wire::isHidden() {
+        return hidden;
+    }
 
-std::string Bus::getName() {
-    return name;
-}
-std::string Bus::getTooltip() {
-    return tooltip;
-}
-Bus::BusType Bus::getType() {
-    return type;
-}
-std::pair<int, int> Bus::getCount() {
-    return count;
-}
-std::vector<Wire> Bus::getWires() {
-    return wires;
-}
-std::optional<ui::Bus> Bus::getDisplayBus() {
-    return displayBus;
-}
+    bool Wire::hasTerminateWith() {
+        return hasTerminate;
+    }
+
+    Value Wire::getTerminateWith() {
+        return terminateWith;
+    }
+
+    Wire::WireType Wire::getType() {
+        return type;
+    }
+
+    Bus::Bus(std::string name, std::string tooltip, BusType type, std::pair<int, int> count, std::vector<Wire> wires,
+             std::optional<ui::Bus> displayBus)
+            : name(name), tooltip(tooltip), type(type), count(count), wires(wires), displayBus(displayBus) {}
+
+    std::string Bus::getName() {
+        return name;
+    }
+
+    std::string Bus::getTooltip() {
+        return tooltip;
+    }
+
+    Bus::BusType Bus::getType() {
+        return type;
+    }
+
+    std::pair<int, int> Bus::getCount() {
+        return count;
+    }
+
+    std::vector<Wire> Bus::getWires() {
+        return wires;
+    }
+
+    std::optional<ui::Bus> Bus::getDisplayBus() {
+        return displayBus;
+    }
 
 } // namespace domain

comdel/domain/bus.h

@@ -11,63 +11,72 @@
 
 namespace domain {
 
-class Wire
-{
-public:
-    enum WireType {
-        WIRE_DEFAULT,
-        WIRED_AND,
-        WIRED_OR,
-        R_WIRE
+    class Wire {
+    public:
+        enum WireType {
+            WIRE_DEFAULT,
+            WIRED_AND,
+            WIRED_OR,
+            R_WIRE
+        };
+
+
+    private:
+        std::string name;
+        WireType type;
+        int width;
+        bool hidden;
+        bool hasTerminate;
+        Value terminateWith;
+
+    public:
+        Wire(std::string name, WireType type, int width, bool hidden, bool hasTerminate, Value terminateWith);
+
+        std::string getName();
+
+        int getWidth();
+
+        bool isHidden();
+
+        bool hasTerminateWith();
+
+        Value getTerminateWith();
+
+        WireType getType();
     };
 
+    class Bus {
+    public:
+        enum BusType {
+            AUTOMATIC,
+            REGULAR,
+            SINGLE_AUTOMATIC
+        };
+    private:
+        std::string name;
+        std::string tooltip;
+        BusType type;
 
-private:
-    std::string name;
-    WireType type;
-    int width;
-    bool hidden;
-    bool hasTerminate;
-    Value terminateWith;
+        std::pair<int, int> count;
+        std::optional<ui::Bus> displayBus;
+        std::vector<Wire> wires;
 
-public:
-    Wire(std::string name, WireType type, int width, bool hidden, bool hasTerminate, Value terminateWith);
+    public:
+        Bus(std::string name, std::string tooltip, BusType type, std::pair<int, int> count, std::vector<Wire> wires,
+            std::optional<ui::Bus> display = std::nullopt);
 
-    std::string getName();
-    int getWidth();
-    bool isHidden();
-    bool hasTerminateWith();
-    Value getTerminateWith();
-    WireType getType();
-};
+        std::string getName();
 
-class Bus
-{
-public:
-    enum BusType {
-        AUTOMATIC,
-        REGULAR,
-        SINGLE_AUTOMATIC
+        std::string getTooltip();
+
+        BusType getType();
+
+        std::pair<int, int> getCount();
+
+        std::vector<Wire> getWires();
+
+        std::optional<ui::Bus> getDisplayBus();
     };
-private:
-    std::string name;
-    std::string tooltip;
-    BusType type;
-
-    std::pair<int, int> count;
-    std::optional<ui::Bus> displayBus;
-    std::vector<Wire> wires;
-
-public:
-    Bus(std::string name, std::string tooltip, BusType type, std::pair<int, int> count, std::vector<Wire> wires, std::optional<ui::Bus> display = std::nullopt);
-
-    std::string getName();
-    std::string getTooltip();
-    BusType getType();
-    std::pair<int, int> getCount();
-    std::vector<Wire> getWires();
-    std::optional<ui::Bus> getDisplayBus();
-};
 
 } // namespace domain
 

comdel/domain/comdel_generator.cpp

@@ -7,345 +7,361 @@
 
 namespace domain {
 
-void generateSchemaFile(std::string& librarySource, Schema *schema, std::ostream &buffer) {
-    buffer << "@source " << librarySource << std::endl << std::endl;
+    void generate_schema(std::string &librarySource, Schema *schema, std::ostream &buffer) {
+        buffer << "@source \"" << librarySource << "\"" << std::endl << std::endl;
 
-    buffer << "@schema {" << std::endl;
+        buffer << "@schema {" << std::endl;
 
-    for(auto &componentInstance: schema->componentInstances) {
-        buffer << "\t"   << "@instance " << componentInstance->name << " " << componentInstance->component.getName() << " {" << std::endl;
-        buffer << "\t\t" << "@position (" << componentInstance->position.first << ", " << componentInstance->position.second << ")" << std::endl;
+        for (auto &componentInstance: schema->componentInstances) {
+            buffer << "\t" << "@instance " << componentInstance->name << " " << componentInstance->component.getName()
+                   << " {" << std::endl;
+            buffer << "\t\t" << "@position (" << componentInstance->position.first << ", "
+                   << componentInstance->position.second << ")" << std::endl;
 
-        for(auto &attribute: componentInstance->attributes) {
-            buffer << "\t\t" << "@attribute " << attribute.name << " " << attribute.value.stringify() << std::endl;
-        }
-
-        buffer << "\t}" << std::endl << std::endl;
-    }
-
-    for(auto &busInstance: schema->busInstances) {
-        buffer << "\t"   << "@instance " << busInstance->name << " " << busInstance->bus.getName() << " {" << std::endl;
-        buffer << "\t\t" << "@position (" << busInstance->position.first << ", " << busInstance->position.second << ")" << std::endl;
-        buffer << "\t\t" << "@size " << busInstance->size << std::endl;
-        buffer << "\t}" << std::endl << std::endl;
-    }
-
-    for(auto &conn: schema->connections) {
-        auto busConn = dynamic_cast<domain::BusConnectionInstance*>(conn.get());
-        if(busConn) {
-            buffer << "\t"  << "@connection (" << busConn->instance->name << "." << busConn->connection.getComponent().pin << ", " << busConn->bus->name << ") {" << std::endl;
-
-            for(auto attribute: busConn->attributes) {
+            for (auto &attribute: componentInstance->attributes) {
                 buffer << "\t\t" << "@attribute " << attribute.name << " " << attribute.value.stringify() << std::endl;
             }
 
-            buffer << "\t"  << "}" << std::endl;
+            buffer << "\t}" << std::endl << std::endl;
         }
-        auto dirConn = dynamic_cast<domain::DirectConnectionInstance*>(conn.get());
-        if(dirConn) {
-            buffer  << "\t"  << "@connection (" << dirConn->instance->name << "." << dirConn->connection.getComponent().pin << ", "
-                    << dirConn->bus->name << ", "
-                    << dirConn->secondInstance->name << "." << dirConn->connection.getSecondComponent()->pin
-                    << ") {" << std::endl;
 
-            for(auto attribute: dirConn->attributes) {
-                buffer << "\t\t" << "@attribute " << attribute.name << " " << attribute.value.stringify() << std::endl;
+        for (auto &busInstance: schema->busInstances) {
+            buffer << "\t" << "@instance " << busInstance->name << " " << busInstance->bus.getName() << " {"
+                   << std::endl;
+            buffer << "\t\t" << "@position (" << busInstance->position.first << ", " << busInstance->position.second
+                   << ")" << std::endl;
+            buffer << "\t\t" << "@size " << busInstance->size << std::endl;
+            buffer << "\t}" << std::endl << std::endl;
+        }
+
+        for (auto &conn: schema->connections) {
+            auto busConn = dynamic_cast<domain::BusConnectionInstance *>(conn.get());
+            if (busConn) {
+                buffer << "\t" << "@connection (" << busConn->instance->name << "."
+                       << busConn->connection.getComponent().pin << ", " << busConn->bus->name << ") {" << std::endl;
+
+                for (auto attribute: busConn->attributes) {
+                    buffer << "\t\t" << "@attribute " << attribute.name << " " << attribute.value.stringify()
+                           << std::endl;
+                }
+
+                buffer << "\t" << "}" << std::endl;
             }
+            auto dirConn = dynamic_cast<domain::DirectConnectionInstance *>(conn.get());
+            if (dirConn) {
+                buffer << "\t" << "@connection (" << dirConn->instance->name << "."
+                       << dirConn->connection.getComponent().pin << ", "
+                       << dirConn->bus->name << ", "
+                       << dirConn->secondInstance->name << "." << dirConn->connection.getSecondComponent()->pin
+                       << ") {" << std::endl;
 
-            buffer << "\t"  << "}" << std::endl;
+                for (auto attribute: dirConn->attributes) {
+                    buffer << "\t\t" << "@attribute " << attribute.name << " " << attribute.value.stringify()
+                           << std::endl;
+                }
+
+                buffer << "\t" << "}" << std::endl;
+            }
+        }
+
+        buffer << "}" << std::endl;
+    }
+
+    std::set<std::string> createImports(Schema *schema);
+
+    std::map<string, string> generateWires(Schema *schema, ostream &ostream);
+
+    void generateSubComponents(Schema *schema, map<string, string> &wires, ostream &buffer);
+
+    void generateDisplay(Schema *schema, ostream &buffer);
+
+    void generate_comdel(Schema *schema, Library &library, std::ostream &buffer) {
+        buffer << library.getHeader() << std::endl;
+
+        std::set<std::string> imports = createImports(schema);
+
+        for (auto &import: imports) {
+            buffer << "#include \"" << library.getComponentDirectory() << "\\" << import << "\"" << std::endl;
+        }
+
+        buffer << "\n\n" << std::endl;
+
+        buffer << "component System" << std::endl << "{" << std::endl;
+
+        if (library.getComponentHeader().has_value()) {
+            buffer << library.getComponentHeader().value() << endl;
+        }
+
+        auto wires = generateWires(schema, buffer);
+
+        generateSubComponents(schema, wires, buffer);
+
+        generateDisplay(schema, buffer);
+
+        buffer << "}";
+    }
+
+    void generateBus(BusInstance *bus, ostream &buffer);
+
+    void generateConnection(ConnectionInstance *connection, ostream &buffer);
+
+    void generateDisplay(Schema *schema, ostream &buffer) {
+        buffer << "\n\tdisplay {\n";
+
+        for (auto &component: schema->componentInstances) {
+            buffer << "\t\tcomponent { x: " << component->position.first << "; y: " << component->position.second
+                   << "; ref: \"" << component->name << "\"; }" << std::endl;
+        }
+
+        for (auto &bus: schema->busInstances) {
+            generateBus(bus.get(), buffer);
+        }
+
+        buffer << "\n";
+
+        for (auto &connection: schema->connections) {
+            generateConnection(connection.get(), buffer);
+        }
+
+        buffer << "\t}\n";
+    }
+
+    void generateConnection(ConnectionInstance *connection, ostream &buffer) {
+        buffer << "\t\tline {x1:" << connection->start.first << "; y1:" << connection->start.second << "; " <<
+               "x2:" << connection->end.first << "; y2:" << connection->end.second << ";}" << "\n";
+    }
+
+    void generateBus(BusInstance *bus, ostream &buffer) {
+        buffer << "\n";
+        buffer << "\t\t// " << bus->name << " bus\n\n";
+
+        if (bus->bus.getDisplayBus().has_value()) {
+            bus->bus.getDisplayBus()->comdel(buffer, bus->position.first, bus->position.second, bus->size);
         }
     }
 
-    buffer << "}" << std::endl;
-}
+    void generateWire(std::string &name, Wire &wire, ostream &buffer);
 
-std::set<std::string> createImports(Schema *schema);
+    std::map<string, string> generateWires(Schema *schema, ostream &buffer) {
+        std::set<string> usedNames;
+        std::map<string, string> usedMappings;
+        for (auto &bus: schema->busInstances) {
+            buffer << "\t//" << bus->name << std::endl;
+            for (auto &wire: bus->bus.getWires()) {
+                std::string name = wire.getName();
+                if (usedNames.count(wire.getName()) > 0) {
+                    name = bus->name + "__" + wire.getName();
+                }
+                if (wire.isHidden()) {
+                    name = "--" + name;
+                }
+                usedNames.insert(name);
+                usedMappings.insert(std::make_pair(bus->name + "." + wire.getName(), name));
 
-std::map<string, string> generateWires(Schema *schema, ostream &ostream);
-
-void generateSubComponents(Schema *schema, map <string, string> &wires, ostream &buffer);
-
-void generateDisplay(Schema *schema, ostream &buffer);
-
-void generateComdelFile(Schema *schema, Library &library, std::ostream &buffer) {
-    buffer << library.getHeader() << std::endl;
-
-    std::set<std::string> imports = createImports(schema);
-
-    for(auto& import: imports) {
-       buffer << "#include \"" << library.getComponentDirectory() << "\\" << import << "\"" << std::endl;
-    }
-
-    buffer << "\n\n" << std::endl;
-
-    buffer << "component System" << std::endl << "{" << std::endl;
-
-    if(library.getComponentHeader().has_value()) {
-        buffer << library.getComponentHeader().value() << endl;
-    }
-
-    auto wires = generateWires(schema, buffer);
-
-    generateSubComponents(schema, wires, buffer);
-
-    generateDisplay(schema, buffer);
-
-    buffer << "}";
-}
-
-void generateBus(BusInstance *bus, ostream &buffer);
-void generateConnection(ConnectionInstance *connection, ostream &buffer);
-
-void generateDisplay(Schema *schema, ostream &buffer) {
-    buffer << "\n\tdisplay {\n";
-
-    for(auto &component: schema->componentInstances) {
-        buffer << "\t\tcomponent { x: " << component->position.first << "; y: " << component->position.second << "; ref: \"" << component->name << "\"; }" << std::endl;
-    }
-
-    for(auto &bus: schema->busInstances) {
-        generateBus(bus.get(), buffer);
-    }
-
-    buffer << "\n";
-
-    for(auto &connection: schema->connections) {
-        generateConnection(connection.get(), buffer);
-    }
-
-    buffer << "\t}\n";
-}
-
-void generateConnection(ConnectionInstance *connection, ostream &buffer) {
-    buffer << "\t\tline {x1:" << connection->start.first << "; y1:" << connection->start.second << "; " <<
-                        "x2:" << connection->end.first << "; y2:" << connection->end.second << ";}" << "\n";
-}
-
-void generateBus(BusInstance *bus, ostream &buffer) {
-    buffer << "\n";
-    buffer << "\t\t// " << bus->name << " bus\n\n";
-
-    if(bus->bus.getDisplayBus().has_value()) {
-        bus->bus.getDisplayBus()->comdel(buffer, bus->position.first, bus->position.second, bus->size);
-    }
-}
-
-void generateWire(std::string &name, Wire& wire, ostream &buffer);
-
-std::map<string, string> generateWires(Schema *schema, ostream &buffer) {
-    std::set<string> usedNames;
-    std::map<string, string> usedMappings;
-    for(auto &bus: schema->busInstances) {
-        buffer << "\t//" << bus->name << std::endl;
-        for(auto& wire: bus->bus.getWires()) {
-            std::string name = wire.getName();
-            if(usedNames.count(wire.getName()) > 0) {
-                name = bus->name + "__" + wire.getName();
+                generateWire(name, wire, buffer);
             }
-            if(wire.isHidden()) {
-                name = "--" + name;
-            }
-            usedNames.insert(name);
-            usedMappings.insert(std::make_pair(bus->name + "." + wire.getName(), name));
-
-            generateWire(name, wire, buffer);
+            buffer << std::endl << std::endl;
         }
-        buffer << std::endl << std::endl;
-    }
-    return usedMappings;
-}
-
-void generateWire(std::string &name, Wire& wire, ostream &buffer) {
-    buffer << "\t";
-    switch (wire.getType()) {
-        case Wire::R_WIRE:
-            buffer << "r_wire";
-            break;
-        case Wire::WIRED_AND:
-            buffer << "wired_and";
-            break;
-        case Wire::WIRED_OR:
-            buffer << "wired_or";
-            break;
-        default:
-            buffer << "wire";
+        return usedMappings;
     }
 
-    if(wire.getWidth() != 1) {
-        buffer << "<" << wire.getWidth() << ">";
+    void generateWire(std::string &name, Wire &wire, ostream &buffer) {
+        buffer << "\t";
+        switch (wire.getType()) {
+            case Wire::R_WIRE:
+                buffer << "r_wire";
+                break;
+            case Wire::WIRED_AND:
+                buffer << "wired_and";
+                break;
+            case Wire::WIRED_OR:
+                buffer << "wired_or";
+                break;
+            default:
+                buffer << "wire";
+        }
+
+        if (wire.getWidth() != 1) {
+            buffer << "<" << wire.getWidth() << ">";
+        }
+        buffer << " " << name << ";" << std::endl;
     }
-    buffer << " " << name << ";" << std::endl;
-}
 
-std::set<std::string> createImports(Schema *schema) {
-    std::set<std::string> importSet;
-    for(auto &component: schema->componentInstances) {
-        importSet.insert(component->component.getSource());
+    std::set<std::string> createImports(Schema *schema) {
+        std::set<std::string> importSet;
+        for (auto &component: schema->componentInstances) {
+            importSet.insert(component->component.getSource());
+        }
+        return importSet;
     }
-    return importSet;
-}
 
-void generateAutomaticPin(DirectConnectionInstance *connection, string name, string pin, map<string, string> wireNames, stringstream &buffer);
+    void
+    generateAutomaticPin(DirectConnectionInstance *connection, string name, string pin, map<string, string> wireNames,
+                         stringstream &buffer);
 
-void generateSingleAutomaticPin(DirectConnectionInstance *instance, string name, string pin,
-                               map <string, string> &wireNames,
-                               stringstream &buffer);
+    void generateSingleAutomaticPin(DirectConnectionInstance *instance, string name, string pin,
+                                    map<string, string> &wireNames,
+                                    stringstream &buffer);
 
-    void generateComponent(Schema *schema, map <string, string> &wires, ostream &buffer,
-                           shared_ptr <ComponentInstance> &component);
+    void generateComponent(Schema *schema, map<string, string> &wires, ostream &buffer,
+                           shared_ptr<ComponentInstance> &component);
 
     void generateSubComponents(Schema *schema, map<string, string> &wires, ostream &buffer) {
 
-    buffer << "\t// components --------------------------------------------" << std::endl;
+        buffer << "\t// components --------------------------------------------" << std::endl;
 
-    for(auto& component: schema->componentInstances) {
-        if(component->component.getType() == Component::MEMORY) {
-            generateComponent(schema, wires, buffer, component);
+        for (auto &component: schema->componentInstances) {
+            if (component->component.getType() == Component::MEMORY) {
+                generateComponent(schema, wires, buffer, component);
+            }
         }
-    }
-    for(auto& component: schema->componentInstances) {
-        if(component->component.getType() != Component::MEMORY) {
-            generateComponent(schema, wires, buffer, component);
-        }
-    }
-}
-
-void generateComponent(Schema *schema, map <string, string> &wires, ostream &buffer,
-                       shared_ptr <ComponentInstance> &component) {
-    buffer << "\tsubcomponent " << component->component.getName() << " " << component->name;
-
-    std::optional<InstanceAttribute> memory;
-
-    std::vector<InstanceAttribute> attributes;
-    for(auto& attr: component->attributes) {
-        if(attr.name != "_memory") {
-            attributes.push_back(attr);
-        } else if(attr.name == "_memory" && attr.value.asMemoryReference().has_value()) {
-            memory = attr;
+        for (auto &component: schema->componentInstances) {
+            if (component->component.getType() != Component::MEMORY) {
+                generateComponent(schema, wires, buffer, component);
+            }
         }
     }
 
-    if(!attributes.empty()) {
-        buffer << "<";
-        buffer << attributes[0].value.stringify();
-        for(int i=1; i<attributes.size(); i++) {
-            buffer << ", " << attributes[i].value.stringify();
+    void generateComponent(Schema *schema, map<string, string> &wires, ostream &buffer,
+                           shared_ptr<ComponentInstance> &component) {
+        buffer << "\tsubcomponent " << component->component.getName() << " " << component->name;
+
+        std::optional<InstanceAttribute> memory;
+
+        std::vector<InstanceAttribute> attributes;
+        for (auto &attr: component->attributes) {
+            if (attr.name != "_memory") {
+                attributes.push_back(attr);
+            } else if (attr.name == "_memory" && attr.value.asMemoryReference().has_value()) {
+                memory = attr;
+            }
         }
-        buffer << ">";
-    }
 
-    stringstream tempOutput;
+        if (!attributes.empty()) {
+            buffer << "<";
+            buffer << attributes[0].value.stringify();
+            for (int i = 1; i < attributes.size(); i++) {
+                buffer << ", " << attributes[i].value.stringify();
+            }
+            buffer << ">";
+        }
 
-    for(auto &pin: component->component.getPins()) {
-        if(schema->hasConnection(component->name, pin.getName())) {
-            auto conn = schema->getConnection(component->name, pin.getName());
-            auto busConn = dynamic_cast<BusConnectionInstance*>(conn);
-            if(busConn != nullptr) {
-                for(auto wire: busConn->connection.getWires()) {
-                    if(wire.isType(Value::ATTRIBUTE_REFERENCE)) {
-                        auto attribute = busConn->getAttribute(wire.asReference());
-                        if(wire.isType(Value::WIRE_REFERENCE)) {
-                            tempOutput << wires[busConn->bus->name + "." + attribute.value.asReference()] << ", ";
-                        } else if(wire.isType(Value::NIL)) {
-                            tempOutput << "*, ";
+        stringstream tempOutput;
+
+        for (auto &pin: component->component.getPins()) {
+            if (schema->hasConnection(component->name, pin.getName())) {
+                auto conn = schema->getConnection(component->name, pin.getName());
+                auto busConn = dynamic_cast<BusConnectionInstance *>(conn);
+                if (busConn != nullptr) {
+                    for (auto wire: busConn->connection.getWires()) {
+                        if (wire.isType(Value::ATTRIBUTE_REFERENCE)) {
+                            auto attribute = busConn->getAttribute(wire.asReference());
+                            if (wire.isType(Value::WIRE_REFERENCE)) {
+                                tempOutput << wires[busConn->bus->name + "." + attribute.value.asReference()] << ", ";
+                            } else if (wire.isType(Value::NIL)) {
+                                tempOutput << "*, ";
+                            } else {
+                                tempOutput << attribute.value.stringify() << ", ";
+                            }
                         } else {
-                            tempOutput << attribute.value.stringify() << ", ";
-                        }
-                    } else {
-                        if(wire.isType(Value::WIRE_REFERENCE)) {
-                            tempOutput << wires[busConn->bus->name + "." + wire.asReference()] << ", ";
-                        } else if(wire.isType(Value::NIL)) {
-                            tempOutput << "*, ";
-                        } else {
-                            tempOutput << wire.stringify() << ", ";
+                            if (wire.isType(Value::WIRE_REFERENCE)) {
+                                tempOutput << wires[busConn->bus->name + "." + wire.asReference()] << ", ";
+                            } else if (wire.isType(Value::NIL)) {
+                                tempOutput << "*, ";
+                            } else {
+                                tempOutput << wire.stringify() << ", ";
+                            }
                         }
                     }
                 }
-            }
-            auto dirConn = dynamic_cast<DirectConnectionInstance*>(conn);
-            if(dirConn != nullptr) {
-                if(dirConn->bus->bus.getType() == Bus::AUTOMATIC) {
-                    generateAutomaticPin(dirConn, component->name, pin.getName(), wires, tempOutput);
-                } else {
-                    generateSingleAutomaticPin(dirConn, component->name, pin.getName(), wires, tempOutput);
+                auto dirConn = dynamic_cast<DirectConnectionInstance *>(conn);
+                if (dirConn != nullptr) {
+                    if (dirConn->bus->bus.getType() == Bus::AUTOMATIC) {
+                        generateAutomaticPin(dirConn, component->name, pin.getName(), wires, tempOutput);
+                    } else {
+                        generateSingleAutomaticPin(dirConn, component->name, pin.getName(), wires, tempOutput);
+                    }
+                }
+            } else {
+                // if no connection exists than defaults must exist
+                for (auto &wire: *pin.getWires()) {
+                    tempOutput << wire.stringify() << ", ";
                 }
             }
+        }
+
+        auto wireList = tempOutput.str();
+        wireList.pop_back();
+        wireList.pop_back(); // remove last COMMA(", ")
+
+        buffer << "(" << wireList << ")";
+
+        if (memory.has_value()) {
+            buffer << " uses " << *memory->value.asMemoryReference();
+        }
+
+        buffer << ";" << std::endl;
+
+    }
+
+    void generateSingleAutomaticPin(DirectConnectionInstance *connection, string name, string pin,
+                                    map<string, string> &wireNames, stringstream &buffer) {
+        std::vector<Value> wires;
+        std::string selected;
+        std::vector<Value> defaults;
+        if (connection->instance->name == name && connection->connection.getComponent().pin == pin) {
+            wires = connection->connection.getWires();
+            selected = connection->attributes[0].value.asReference();
+            defaults = *connection->instance->component.getPin(pin).getWires();
         } else {
-            // if no connection exists than defaults must exist
-            for(auto& wire: *pin.getWires()) {
-                tempOutput << wire.stringify() << ", ";
+            wires = *connection->connection.getSecondWires();
+            selected = connection->attributes[1].value.asReference();
+            defaults = *connection->secondInstance->component.getPin(pin).getWires();
+        }
+
+        for (int i = 0; i < wires.size(); i++) {
+            if (wires[i].isType(Value::STRING)) {
+                if (wires[i].asString() == selected) {
+                    buffer << wireNames[connection->bus->name + "." + connection->bus->bus.getWires()[0].getName()]
+                           << ", ";
+                } else {
+                    buffer << defaults[i].stringify();
+                }
+            } else {
+                buffer << wires[i].stringify() << ", ";
             }
         }
     }
 
-    auto wireList = tempOutput.str();
-    wireList.pop_back();
-    wireList.pop_back(); // remove last COMMA(", ")
-
-    buffer << "(" << wireList << ")";
-
-    if(memory.has_value()) {
-        buffer << " uses " << *memory->value.asMemoryReference();
-    }
-
-    buffer << ";" << std::endl;
-
-}
-
-void generateSingleAutomaticPin(DirectConnectionInstance *connection, string name, string pin, map <string, string> &wireNames, stringstream &buffer) {
-    std::vector<Value> wires;
-    std::string selected;
-    std::vector<Value> defaults;
-    if(connection->instance->name == name && connection->connection.getComponent().pin == pin) {
-        wires = connection->connection.getWires();
-        selected = connection->attributes[0].value.asReference();
-        defaults = *connection->instance->component.getPin(pin).getWires();
-    } else {
-        wires = *connection->connection.getSecondWires();
-        selected = connection->attributes[1].value.asReference();
-        defaults = *connection->secondInstance->component.getPin(pin).getWires();
-    }
-
-    for(int i=0; i<wires.size(); i++) {
-        if(wires[i].isType(Value::STRING)) {
-            if(wires[i].asString() == selected) {
-                buffer << wireNames[connection->bus->name + "." + connection->bus->bus.getWires()[0].getName()] << ", ";
-            } else {
-                buffer << defaults[i].stringify();
-            }
+    void
+    generateAutomaticPin(DirectConnectionInstance *connection, string name, string pin, map<string, string> wireNames,
+                         stringstream &buffer) {
+        std::vector<Value> wires;
+        if (connection->instance->name == name && connection->connection.getComponent().pin == pin) {
+            wires = connection->connection.getWires();
         } else {
-            buffer << wires[i].stringify() << ", ";
+            wires = *connection->connection.getSecondWires();
         }
-    }
-}
-
-void generateAutomaticPin(DirectConnectionInstance *connection, string name, string pin, map<string, string> wireNames, stringstream &buffer) {
-    std::vector<Value> wires;
-    if(connection->instance->name == name && connection->connection.getComponent().pin == pin) {
-        wires = connection->connection.getWires();
-    } else {
-        wires = *connection->connection.getSecondWires();
-    }
-    for(auto& wire: wires) {
-        if(wire.isType(Value::ATTRIBUTE_REFERENCE)) {
-            auto attribute = connection->getAttribute(wire.asReference());
-            if(wire.isType(Value::WIRE_REFERENCE)) {
-                buffer << wireNames[connection->bus->name + "." + attribute.value.asReference()] << ", ";
-            } else if(wire.isType(Value::NIL)) {
-                buffer << "*, ";
+        for (auto &wire: wires) {
+            if (wire.isType(Value::ATTRIBUTE_REFERENCE)) {
+                auto attribute = connection->getAttribute(wire.asReference());
+                if (wire.isType(Value::WIRE_REFERENCE)) {
+                    buffer << wireNames[connection->bus->name + "." + attribute.value.asReference()] << ", ";
+                } else if (wire.isType(Value::NIL)) {
+                    buffer << "*, ";
+                } else {
+                    buffer << attribute.value.stringify() << ", ";
+                }
             } else {
-                buffer << attribute.value.stringify() << ", ";
-            }
-        } else {
-            if(wire.isType(Value::WIRE_REFERENCE)) {
-                buffer << wireNames[connection->bus->name + "." + wire.asReference()] << ", ";
-            } else if(wire.isType(Value::NIL)) {
-                buffer << "*, ";
-            } else {
-                buffer << wire.stringify() << ", ";
+                if (wire.isType(Value::WIRE_REFERENCE)) {
+                    buffer << wireNames[connection->bus->name + "." + wire.asReference()] << ", ";
+                } else if (wire.isType(Value::NIL)) {
+                    buffer << "*, ";
+                } else {
+                    buffer << wire.stringify() << ", ";
+                }
             }
         }
     }
-}
 
 } // domain

comdel/domain/comdel_generator.h

@@ -7,9 +7,9 @@
 
 namespace domain {
 
-void generateSchemaFile(std::string& librarySource, Schema *schema, std::ostream &buffer);
+    void generate_schema(std::string &librarySource, Schema *schema, std::ostream &buffer);
 
-void generateComdelFile(Schema *schema, Library &library, std::ostream &buffer);
+    void generate_comdel(Schema *schema, Library &library, std::ostream &buffer);
 
 } // domain
 

comdel/domain/comdel_validator.cpp

@@ -0,0 +1,206 @@
+#include "comdel_validator.h"
+#include "library.h"
+
+namespace domain {
+
+    std::vector<ValidationError> ComdelValidator::validateSchema(Schema &schema, ValidationContext context) {
+        std::vector<ValidationError> errors;
+
+        context.instance = nullptr;
+        context.attribute = nullptr;
+
+        for (auto &instance: schema.componentInstances) {
+            auto result = validateComponent(instance.get(), context);
+            errors.insert(errors.end(), result.begin(), result.end());
+        }
+        return errors;
+    }
+
+    std::vector<ValidationError>
+    ComdelValidator::validateInstanceCount(Schema &schema, Library &library, ValidationContext context) {
+        std::vector<ValidationError> errors;
+
+        // validate instance count
+        std::map<std::string, int> instanceMap;
+        for (auto &inst: schema.componentInstances) {
+            instanceMap[inst->component.getName()]++;
+        }
+
+        for (auto comp: library.getComponents()) {
+            int count = instanceMap[comp.getName()];
+
+            context.attributes["componentName"] = Value::fromString(comp.getName());
+            context.attributes["min"] = Value::fromInt(comp.getCount().first);
+            context.attributes["max"] = Value::fromInt(comp.getCount().second);
+            context.attributes["count"] = Value::fromInt(count);
+
+            if (count < comp.getCount().first) {
+                auto message = populateMessage(
+                        "Not enough instances of component '{componentName}' required at least {min}, found {count}",
+                        context);
+                errors.push_back(ValidationError{nullptr, nullptr, Action::ERROR, message});
+            } else if (count > comp.getCount().second) {
+                auto message = populateMessage(
+                        "To many instances of component '{componentName}' allow at most {max}, found {count}", context);
+                errors.push_back(ValidationError{nullptr, nullptr, Action::ERROR, message});
+            }
+        }
+
+
+        // validate bus instance count
+        std::map<std::string, int> busInstanceMap;
+        for (auto &inst: schema.busInstances) {
+            busInstanceMap[inst->bus.getName()]++;
+        }
+
+        for (auto bus: library.getBuses()) {
+            int count = busInstanceMap[bus.getName()];
+
+            context.attributes["busName"] = Value::fromString(bus.getName());
+            context.attributes["min"] = Value::fromInt(bus.getCount().first);
+            context.attributes["max"] = Value::fromInt(bus.getCount().second);
+            context.attributes["count"] = Value::fromInt(count);
+
+            if (count < bus.getCount().first) {
+                auto message = populateMessage(
+                        "Not enough instances of bus '{busName}' required at least {min}, found {count}", context);
+                errors.push_back(ValidationError{nullptr, nullptr, Action::ERROR, message});
+            } else if (count > bus.getCount().second) {
+                auto message = populateMessage(
+                        "To many instances of bus '{busName}' allow at most {max}, found {count}", context);
+                errors.push_back(ValidationError{nullptr, nullptr, Action::ERROR, message});
+            }
+        }
+
+        return errors;
+    }
+
+    std::vector<ValidationError>
+    ComdelValidator::validatePinConnections(Schema &schema, Library &library, ValidationContext context) {
+        std::vector<ValidationError> errors;
+
+        for (auto &inst: schema.componentInstances) {
+            for (auto &pin: inst->component.getPins()) {
+                if (pin.getConnection().getType() == PinConnection::REQUIRED) {
+                    if (!connectionExists(schema, inst, pin)) {
+                        context.instance = inst.get();
+                        context.attributes["instanceName"] = Value::fromString(inst->name);
+                        auto message = populateMessage(pin.getConnection().getMessage(), context);
+                        errors.push_back(ValidationError{nullptr, nullptr, Action::ERROR, message});
+                    }
+                }
+            }
+        }
+
+        return errors;
+    }
+
+    std::vector<ValidationError>
+    ComdelValidator::validateComponent(ComponentInstance *instance, ValidationContext context) {
+        std::vector<ValidationError> errors;
+
+        context.instance = instance;
+        context.attributes.clear();
+
+        for (auto &attribute: instance->attributes) {
+            context.attributes[attribute.name] = attribute.value;
+        }
+
+        for (auto &rule: instance->component.getRules()) {
+            auto result = validateRule(rule, context);
+            if (result) {
+                errors.push_back(*result);
+            }
+        }
+
+        for (auto &attribute: instance->attributes) {
+            auto result = validateAttribute(&attribute, context);
+            errors.insert(errors.end(), result.begin(), result.end());
+        }
+
+        return errors;
+    }
+
+    std::vector<ValidationError>
+    ComdelValidator::validateAttribute(InstanceAttribute *attribute, ValidationContext context) {
+        std::vector<ValidationError> errors;
+        if (attribute->attribute.getPopup()) {
+            Popup popup = *attribute->attribute.getPopup();
+            context.attribute = attribute;
+            context.attributes = std::map<std::string, Value>{{attribute->name, attribute->value}};
+
+            for (auto &rule: popup.getRules()) {
+                auto result = validateRule(rule, context);
+                if (result) {
+                    errors.push_back(*result);
+                }
+            }
+        }
+        return errors;
+    }
+
+    std::optional<ValidationError> ComdelValidator::validateRule(Rule rule, ValidationContext context) {
+        RuleContext ruleContext;
+        ruleContext.addressSpaces = context.addressSpaces;
+        ruleContext.attributes = context.attributes;
+        ruleContext.function = validators;
+        auto action = rule.evaluate(ruleContext);
+        if (action) {
+            std::string message = this->populateMessage(action->getMessage(), context);
+            return ValidationError{context.instance, context.attribute, action->getType(), message};
+        }
+        return nullopt;
+    }
+
+    std::string ComdelValidator::populateMessage(string source, ValidationContext context) {
+        for (auto &[key, value]: context.attributes) {
+            source = replacePlaceholder(source, key, value);
+        }
+        return source;
+    }
+
+    string ComdelValidator::replacePlaceholder(string source, string key, Value value) {
+        key = "{" + key + "}";
+        auto placeholderValue = value.string();
+
+        auto found = source.find(key);
+        while (found != string::npos) {
+            source.replace(found, key.length(), placeholderValue);
+            found = source.find(key);
+        }
+        return source;
+    }
+
+    bool ComdelValidator::connectionExists(Schema &schema, shared_ptr<ComponentInstance> &component, Pin &pin) {
+        for (auto conn: schema.connections) {
+            auto busConnection = dynamic_cast<BusConnectionInstance *>(conn.get());
+            if (busConnection != nullptr) {
+                if (busConnection->instance->name == component->name &&
+                    busConnection->connection.getComponent().pin == pin.getName()) {
+                    return true;
+                }
+            }
+
+            auto directConnection = dynamic_cast<DirectConnectionInstance *>(conn.get());
+            if (directConnection != nullptr) {
+                if (directConnection->instance->name == component->name &&
+                    busConnection->connection.getComponent().pin == pin.getName()) {
+                    return true;
+                }
+                if (directConnection->secondInstance->name == component->name &&
+                    busConnection->connection.getSecondComponent()->pin == pin.getName()) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    ComdelValidator::ComdelValidator(std::vector<FunctionValidator *> validators) {
+        for (auto *validator: validators) {
+            validator->clear();
+            this->validators.insert(std::make_pair(validator->getName(), validator));
+        }
+    }
+
+}

comdel/domain/comdel_validator.h

@@ -0,0 +1,52 @@
+#ifndef COMDEL_VALIDATOR_H
+#define COMDEL_VALIDATOR_H
+
+#include "instance.h"
+#include "schema.h"
+#include "library.h"
+
+namespace domain {
+
+    struct ValidationError {
+        ComponentInstance *instance;
+        InstanceAttribute *attribute;
+        Action::ActionType type;
+        std::string message;
+    };
+
+    struct ValidationContext {
+        ComponentInstance *instance;
+        InstanceAttribute *attribute;
+        std::map<std::string, AddressSpace> addressSpaces;
+        std::map<std::string, Value> attributes;
+    };
+
+    class ComdelValidator {
+    public:
+        std::vector<ValidationError> validateSchema(Schema &schema, ValidationContext context);
+
+        std::vector<ValidationError> validateComponent(ComponentInstance *instance, ValidationContext context);
+
+        std::vector<ValidationError> validateAttribute(InstanceAttribute *attribute, ValidationContext context);
+
+        std::optional<ValidationError> validateRule(Rule rule, ValidationContext context);
+
+        std::vector<ValidationError> validateInstanceCount(Schema &schema, Library &library, ValidationContext context);
+
+        std::vector<ValidationError>
+        validatePinConnections(Schema &schema, Library &library, ValidationContext context);
+
+        ComdelValidator(std::vector<FunctionValidator *> validators);
+
+    private:
+        std::map<std::string, FunctionValidator *> validators;
+
+        std::string populateMessage(string message, ValidationContext context);
+
+        string replacePlaceholder(string message, const string name, Value value);
+
+        bool connectionExists(Schema &schema, shared_ptr<ComponentInstance> &component, Pin &pin);
+    };
+
+}
+#endif //COMDEL_VALIDATOR_H

comdel/domain/comdelvalidator.cpp

@@ -1,187 +0,0 @@
-#include "comdelvalidator.h"
-#include "library.h"
-
-namespace domain {
-
-std::vector<ValidationError> ComdelValidator::validateSchema(Schema &schema, ValidationContext context) {
-    std::vector<ValidationError> errors;
-
-    context.instance = nullptr;
-    context.attribute = nullptr;
-
-    for(auto &instance: schema.componentInstances) {
-        auto result = validateComponent(instance.get(), context);
-        errors.insert(errors.end(), result.begin(), result.end());
-    }
-    return errors;
-}
-
-    std::vector<ValidationError> ComdelValidator::validateInstanceCount(Schema& schema, Library& library, ValidationContext context) {
-        std::vector<ValidationError> errors;
-
-        // validate instance count
-        std::map<std::string, int> instanceMap;
-        for(auto& inst: schema.componentInstances) {
-            instanceMap[inst->component.getName()]++;
-        }
-
-        for(auto comp: library.getComponents()) {
-            int count = instanceMap[comp.getName()];
-
-            context.attributes["componentName"] = Value::fromString(comp.getName());
-            context.attributes["min"] = Value::fromInt(comp.getCount().first);
-            context.attributes["max"] = Value::fromInt(comp.getCount().second);
-            context.attributes["count"] = Value::fromInt(count);
-
-            if(count < comp.getCount().first) {
-                auto message = populateMessage("Not enough instances of component '{componentName}' required at least {min}, found {count}", context);
-                errors.push_back(ValidationError{nullptr, nullptr, Action::ERROR, message});
-            } else if(count > comp.getCount().second) {
-                auto message = populateMessage("To many instances of component '{componentName}' allow at most {max}, found {count}", context);
-                errors.push_back(ValidationError{nullptr, nullptr, Action::ERROR, message});
-            }
-        }
-
-
-        // validate bus instance count
-        std::map<std::string, int> busInstanceMap;
-        for(auto& inst: schema.busInstances) {
-            busInstanceMap[inst->bus.getName()]++;
-        }
-
-        for(auto bus: library.getBuses()) {
-            int count = busInstanceMap[bus.getName()];
-
-            context.attributes["busName"] = Value::fromString(bus.getName());
-            context.attributes["min"] = Value::fromInt(bus.getCount().first);
-            context.attributes["max"] = Value::fromInt(bus.getCount().second);
-            context.attributes["count"] = Value::fromInt(count);
-
-            if(count < bus.getCount().first) {
-                auto message = populateMessage("Not enough instances of bus '{busName}' required at least {min}, found {count}", context);
-                errors.push_back(ValidationError{nullptr, nullptr, Action::ERROR, message});
-            } else if(count > bus.getCount().second) {
-                auto message = populateMessage("To many instances of bus '{busName}' allow at most {max}, found {count}", context);
-                errors.push_back(ValidationError{nullptr, nullptr, Action::ERROR, message});
-            }
-        }
-
-        return errors;
-    }
-
-    std::vector<ValidationError> ComdelValidator::validatePinConnections(Schema &schema, Library &library, ValidationContext context) {
-        std::vector<ValidationError> errors;
-
-        for(auto& inst: schema.componentInstances) {
-            for(auto& pin: inst->component.getPins()) {
-                if(pin.getConnection().getType() == PinConnection::REQUIRED) {
-                    if(!connectionExists(schema, inst, pin)) {
-                        context.instance = inst.get();
-                        context.attributes["instanceName"] = Value::fromString(inst->name);
-                        auto message = populateMessage(pin.getConnection().getMessage(), context);
-                        errors.push_back(ValidationError{nullptr, nullptr, Action::ERROR, message});
-                    }
-                }
-            }
-        }
-
-        return errors;
-    }
-
-std::vector<ValidationError> ComdelValidator::validateComponent(ComponentInstance* instance, ValidationContext context) {
-    std::vector<ValidationError> errors;
-
-    context.instance = instance;
-    context.attributes.clear();
-
-    for(auto &attribute: instance->attributes) {
-        context.attributes[attribute.name] = attribute.value;
-    }
-
-    for(auto &rule: instance->component.getRules()) {
-        auto result = validateRule(rule, context);
-        if(result) {
-            errors.push_back(*result);
-        }
-    }
-
-    for(auto &attribute: instance->attributes) {
-        auto result = validateAttribute(&attribute, context);
-        errors.insert(errors.end(), result.begin(), result.end());
-    }
-
-    return errors;
-}
-
-std::vector<ValidationError> ComdelValidator::validateAttribute(InstanceAttribute *attribute, ValidationContext context) {
-    std::vector<ValidationError> errors;
-    if(attribute->attribute.getPopup()) {
-        Popup popup = *attribute->attribute.getPopup();
-        context.attribute = attribute;
-        context.attributes = std::map<std::string, Value>{{attribute->name, attribute->value}};
-
-        for(auto &rule: popup.getRules()) {
-            auto result = validateRule(rule, context);
-            if(result) {
-                errors.push_back(*result);
-            }
-        }
-    }
-    return errors;
-}
-
-std::optional<ValidationError> ComdelValidator::validateRule(Rule rule, ValidationContext context) {
-    RuleContext ruleContext;
-    ruleContext.addressSpaces = context.addressSpaces;
-    ruleContext.attributes = context.attributes;
-    ruleContext.function = validators;
-    auto action = rule.evaluate(ruleContext);
-    if (action) {
-        std::string message = this->populateMessage(action->getMessage(), context);
-        return ValidationError{context.instance, context.attribute, action->getType(), message};
-    }
-    return nullopt;
-}
-
-std::string ComdelValidator::populateMessage(string source, ValidationContext context) {
-    for(auto &[key, value]: context.attributes) {
-        source = replacePlaceholder(source, key, value);
-    }
-    return source;
-}
-
-string ComdelValidator::replacePlaceholder(string source, string key, Value value) {
-    key = "{" + key + "}";
-    auto placeholderValue = value.string();
-
-    auto found = source.find(key);
-    while(found != string::npos) {
-        source.replace(found, key.length(), placeholderValue);
-        found = source.find(key);
-    }
-    return source;
-}
-
-    bool ComdelValidator::connectionExists(Schema &schema, shared_ptr<ComponentInstance> &component, Pin &pin) {
-        for(auto conn: schema.connections) {
-            auto busConnection = dynamic_cast<BusConnectionInstance*>(conn.get());
-            if(busConnection != nullptr) {
-                if(busConnection->instance->name == component->name && busConnection->connection.getComponent().pin == pin.getName()) {
-                    return true;
-                }
-            }
-
-            auto directConnection = dynamic_cast<DirectConnectionInstance*>(conn.get());
-            if(directConnection != nullptr) {
-                if(directConnection->instance->name == component->name && busConnection->connection.getComponent().pin == pin.getName()) {
-                    return true;
-                }
-                if(directConnection->secondInstance->name == component->name && busConnection->connection.getSecondComponent()->pin == pin.getName()) {
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
-
-}

comdel/domain/comdelvalidator.h

@@ -1,54 +0,0 @@
-#ifndef COMDEL_VALIDATOR_H
-#define COMDEL_VALIDATOR_H
-
-#include "instance.h"
-#include "schema.h"
-#include "library.h"
-
-namespace domain {
-
-struct ValidationError
-{
-    ComponentInstance *instance;
-    InstanceAttribute *attribute;
-    Action::ActionType type;
-    std::string message;
-};
-
-struct ValidationContext {
-    ComponentInstance *instance;
-    InstanceAttribute *attribute;
-    std::map<std::string, AddressSpace> addressSpaces;
-    std::map<std::string, Value> attributes;
-};
-
-class ComdelValidator
-{
-public:
-    std::vector<ValidationError> validateSchema(Schema& schema, ValidationContext context);
-    std::vector<ValidationError> validateComponent(ComponentInstance *instance, ValidationContext context);
-    std::vector<ValidationError> validateAttribute(InstanceAttribute *attribute, ValidationContext context);
-    std::optional<ValidationError> validateRule(Rule rule, ValidationContext context);
-
-    std::vector<ValidationError> validateInstanceCount(Schema &schema, Library& library, ValidationContext context);
-    std::vector<ValidationError> validatePinConnections(Schema &schema, Library& library, ValidationContext context);
-
-    ComdelValidator(std::vector<FunctionValidator*> validators) {
-        for(auto* validator: validators) {
-            validator->clear();
-            this->validators.insert(std::make_pair(validator->getName(), validator));
-        }
-    }
-
-private:
-    std::map<std::string, FunctionValidator*> validators;
-
-    std::string populateMessage(string message, ValidationContext context);
-
-    string replacePlaceholder(string message, const string name, Value value);
-
-    bool connectionExists(Schema &schema, shared_ptr <ComponentInstance> &component, Pin &pin);
-};
-
-}
-#endif //COMDEL_VALIDATOR_H

comdel/domain/component.cpp

@@ -2,84 +2,97 @@
 
 namespace domain {
 
-Component::Component(string name, string tooltip, string source, ComponentType type,
-          vector<Rule> rules, string instanceName, pair<int, int> count, Display display,
-          vector<Pin> pins, vector<Attribute> attributes)
-    : name(name), tooltip(tooltip), source(source), type(type), rules(rules), instanceName(instanceName), count(count), display(display), pins(pins), attributes(attributes)
-{}
+    Component::Component(string name, string tooltip, string source, ComponentType type,
+                         vector<Rule> rules, string instanceName, pair<int, int> count, Display display,
+                         vector<Pin> pins, vector<Attribute> attributes)
+            : name(name), tooltip(tooltip), source(source), type(type), rules(rules), instanceName(instanceName),
+              count(count), display(display), pins(pins), attributes(attributes) {}
 
-std::string Component::getName() {
-    return name;
-}
-std::string Component::getTooltip() {
-    return tooltip;
-}
-std::string Component::getSource() {
-    return source;
-}
-Component::ComponentType Component::getType() {
-    return type;
-}
-std::vector<Rule> Component::getRules() {
-    return rules;
-}
-std::string Component::getInstanceName() {
-    return instanceName;
-}
-std::pair<int, int> Component::getCount() {
-    return count;
-}
-Display Component::getDisplay() {
-    return display;
-}
-
-std::vector<Pin> Component::getPins() {
-    return pins;
-}
-Pin Component::getPin(std::string pin) {
-    for(uint i=0; i<pins.size(); i++) {
-        if(pins[i].getName() == pin) {
-            return pins[i];
-        }
+    std::string Component::getName() {
+        return name;
     }
-    throw std::exception();
-}
 
-bool Component::hasPin(std::string name) {
-    for(auto pin: pins) {
-        if(pin.getName() == name) {
-            return true;
-        }
+    std::string Component::getTooltip() {
+        return tooltip;
     }
-    return false;
-}
 
-std::vector<Attribute> Component::getAttributes() {
-    return attributes;
-}
-Attribute Component::getAttribute(std::string attribute) {
-    for(uint i=0; i<attributes.size(); i++) {
-        if(attributes[i].getName() == attribute) {
-            return attributes[i];
-        }
+    std::string Component::getSource() {
+        return source;
     }
-    throw std::exception();
-}
-bool Component::hasAttribute(std::string name, Value::ValueType type) {
-    for(uint i=0; i<attributes.size(); i++) {
-        if(attributes[i].getName() == name && attributes[i].getDefault().getType() == type) {
-            return true;
-        }
-        if(attributes[i].getName() == name && (type == Value::NIL && (attributes[i].getDefault().getType() == Value::MEMORY_REFERENCE || attributes[i].getDefault().getType() == Value::WIRE_REFERENCE))) {
-            return true;
-        }
-        if(attributes[i].getName() == name && (type == Value::UNDEFINED && (attributes[i].getDefault().getType() == Value::MEMORY_REFERENCE || attributes[i].getDefault().getType() == Value::WIRE_REFERENCE))) {
-            return true;
-        }
-    }
-    return false;
-}
 
+    Component::ComponentType Component::getType() {
+        return type;
+    }
+
+    std::vector<Rule> Component::getRules() {
+        return rules;
+    }
+
+    std::string Component::getInstanceName() {
+        return instanceName;
+    }
+
+    std::pair<int, int> Component::getCount() {
+        return count;
+    }
+
+    Display Component::getDisplay() {
+        return display;
+    }
+
+    std::vector<Pin> Component::getPins() {
+        return pins;
+    }
+
+    Pin Component::getPin(std::string pin) {
+        for (auto & p: pins) {
+            if (p.getName() == pin) {
+                return p;
+            }
+        }
+        throw std::exception();
+    }
+
+    bool Component::hasPin(std::string name) {
+        for (auto pin: pins) {
+            if (pin.getName() == name) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    std::vector<Attribute> Component::getAttributes() {
+        return attributes;
+    }
+
+    Attribute Component::getAttribute(std::string attribute) {
+        for (auto & attr : attributes) {
+            if (attr.getName() == attribute) {
+                return attr;
+            }
+        }
+        throw std::exception();
+    }
+
+    bool Component::hasAttribute(std::string name, Value::ValueType type) {
+        for (auto & attribute : attributes) {
+            if (attribute.getName() == name && attribute.getDefault().getType() == type) {
+                return true;
+            }
+            if (attribute.getName() == name && (type == Value::NIL &&
+                                                    (attribute.getDefault().getType() == Value::MEMORY_REFERENCE ||
+                                                     attribute.getDefault().getType() == Value::WIRE_REFERENCE))) {
+                return true;
+            }
+            if (attribute.getName() == name && (type == Value::UNDEFINED &&
+                                                    (attribute.getDefault().getType() == Value::MEMORY_REFERENCE ||
+                                                     attribute.getDefault().getType() == Value::WIRE_REFERENCE))) {
+                return true;
+            }
+        }
+        return false;
+    }
 
 
 } // namespace domain

comdel/domain/component.h

@@ -11,56 +11,65 @@
 
 namespace domain {
 
-using namespace std;
+    using namespace std;
+
+    class Component {
+    public:
+        enum ComponentType {
+            OTHER,
+            PROCESSOR,
+            MEMORY
+        };
+
+    private:
+        std::string name;
+        std::string tooltip;
+        std::string source;
+        ComponentType type;
+        std::vector<Rule> rules;
+        std::string instanceName;
+        std::pair<int, int> count;
+        Display display;
+
+        std::vector<Pin> pins;
+        std::vector<Attribute> attributes;
+
+    public:
+
+        Component(string name, string tooltip, string source, ComponentType type,
+                  vector<Rule> rules, string instanceName, pair<int, int> count, Display display,
+                  vector<Pin> pins, vector<Attribute> attributes);
+
+        std::string getName();
+
+        std::string getTooltip();
+
+        std::string getSource();
+
+        ComponentType getType();
+
+        std::vector<Rule> getRules();
+
+        std::string getInstanceName();
+
+        std::pair<int, int> getCount();
+
+        Display getDisplay();
+
+        std::vector<Pin> getPins();
+
+        Pin getPin(std::string pin);
+
+        std::vector<Attribute> getAttributes();
+
+        Attribute getAttribute(std::string attribute);
+
+        bool hasAttribute(std::string name, Value::ValueType type);
+
+        bool hasPin(std::string name);
 
-class Component
-{
-public:
-    enum ComponentType {
-        OTHER,
-        PROCESSOR,
-        MEMORY
     };
 
-private:
-    std::string name;
-    std::string tooltip;
-    std::string source;
-    ComponentType type;
-    std::vector<Rule> rules;
-    std::string instanceName;
-    std::pair<int, int> count;
-    Display display;
-
-    std::vector<Pin> pins;
-    std::vector<Attribute> attributes;
-
-public:
-
-    Component(string name, string tooltip, string source, ComponentType type,
-              vector<Rule> rules, string instanceName, pair<int, int> count, Display display,
-              vector<Pin> pins, vector<Attribute> attributes);
-
-    std::string getName();
-    std::string getTooltip();
-    std::string getSource();
-    ComponentType getType();
-    std::vector<Rule> getRules();
-    std::string getInstanceName();
-    std::pair<int, int> getCount();
-    Display getDisplay();
-
-    std::vector<Pin> getPins();
-    Pin getPin(std::string pin);
-
-    std::vector<Attribute> getAttributes();
-    Attribute getAttribute(std::string attribute);
-    bool hasAttribute(std::string name, Value::ValueType type);
-
-    bool hasPin(std::string name);
-
-};
-
 } // namespace domain
 
 #endif // DOMAIN_COMPONENT_H

comdel/domain/connection.cpp

@@ -2,74 +2,77 @@
 
 namespace domain {
 
-Connection::Connection(ConnectionComponent first, std::optional<ConnectionComponent> second,
-            std::string bus, std::vector<Attribute> attributes,
-            std::vector<Value> firstWires, std::optional<std::vector<Value>> secondWires)
-    : first(first), second(second), bus(bus), attributes(attributes), firstWires(firstWires), secondWires(secondWires)
-{}
+    Connection::Connection(ConnectionComponent first, std::optional<ConnectionComponent> second,
+                           std::string bus, std::vector<Attribute> attributes,
+                           std::vector<Value> firstWires, std::optional<std::vector<Value>> secondWires)
+            : first(first), second(second), bus(bus), attributes(attributes), firstWires(firstWires),
+              secondWires(secondWires) {}
 
-ConnectionComponent Connection::getComponent() {
-    return first;
-}
-std::optional<ConnectionComponent> Connection::getSecondComponent() {
-    return second;
-}
-
-std::string Connection::getBus() {
-    return bus;
-}
-
-std::vector<Attribute> Connection::getAttributes() {
-    return attributes;
-}
-std::vector<Value> Connection::getWires() {
-    return firstWires;
-}
-std::optional<std::vector<Value>> Connection::getSecondWires() {
-    return secondWires;
-}
-
-Attribute Connection::getAttribute(std::string name) {
-    for(unsigned int i=0; i<attributes.size(); i++) {
-        if(attributes[i].getName() == name) {
-            return attributes[i];
-        }
+    ConnectionComponent Connection::getComponent() {
+        return first;
     }
-    throw std::exception();
-}
 
-bool Connection::hasAttribute(std::string name) {
-    for(unsigned int i=0; i<attributes.size(); i++) {
-        if(attributes[i].getName() == name) {
-            return true;
-        }
+    std::optional<ConnectionComponent> Connection::getSecondComponent() {
+        return second;
     }
-    return false;
-}
 
-bool Connection::isConnecting(ConnectionComponent component) {
-    return first == component || (second.has_value() && *second == component);
-}
+    std::string Connection::getBus() {
+        return bus;
+    }
 
-bool Connection::isConnecting(ConnectionComponent component, std::string bus) {
-    return this->bus == bus && (first == component || (second.has_value() && *second == component));
-}
+    std::vector<Attribute> Connection::getAttributes() {
+        return attributes;
+    }
 
-bool Connection::isConnecting(ConnectionComponent component, std::string bus, ConnectionComponent secondComponent) {
-    if(!second.has_value()) {
+    std::vector<Value> Connection::getWires() {
+        return firstWires;
+    }
+
+    std::optional<std::vector<Value>> Connection::getSecondWires() {
+        return secondWires;
+    }
+
+    Attribute Connection::getAttribute(std::string name) {
+        for (unsigned int i = 0; i < attributes.size(); i++) {
+            if (attributes[i].getName() == name) {
+                return attributes[i];
+            }
+        }
+        throw std::exception();
+    }
+
+    bool Connection::hasAttribute(std::string name) {
+        for (unsigned int i = 0; i < attributes.size(); i++) {
+            if (attributes[i].getName() == name) {
+                return true;
+            }
+        }
         return false;
     }
-    return  (this->first == component && this->bus == bus && this->second == secondComponent) ||
-            (this->first == secondComponent && this->bus == bus && this->second == component);
-}
+
+    bool Connection::isConnecting(ConnectionComponent component) {
+        return first == component || (second.has_value() && *second == component);
+    }
+
+    bool Connection::isConnecting(ConnectionComponent component, std::string bus) {
+        return this->bus == bus && (first == component || (second.has_value() && *second == component));
+    }
+
+    bool Connection::isConnecting(ConnectionComponent component, std::string bus, ConnectionComponent secondComponent) {
+        if (!second.has_value()) {
+            return false;
+        }
+        return (this->first == component && this->bus == bus && this->second == secondComponent) ||
+               (this->first == secondComponent && this->bus == bus && this->second == component);
+    }
 
 
     bool Connection::isConnecting(ConnectionComponent component, ConnectionComponent secondComponent) {
-        if(!second.has_value()) {
+        if (!second.has_value()) {
             return false;
         }
-        return  (this->first == component && this->second == secondComponent) ||
-                (this->first == secondComponent && this->second == component);
+        return (this->first == component && this->second == secondComponent) ||
+               (this->first == secondComponent && this->second == component);
     }
 
 

comdel/domain/connection.h

@@ -8,65 +8,68 @@
 
 namespace domain {
 
-struct ConnectionComponent
-{
-    std::string component;
-    std::string pin;
+    struct ConnectionComponent {
+        std::string component;
+        std::string pin;
 
-    bool operator==(const ConnectionComponent& rhs) const
-    {
-        return (component == rhs.component) && (pin == rhs.pin);
-    }
-    bool operator!=(const ConnectionComponent& rhs) const
-    {
-        return !operator==(rhs);
-    }
-    bool operator<(const ConnectionComponent& rhs) const
-    {
-        if(component < rhs.component) {
-            return true;
-        } else if(component == rhs.component) {
-            if(pin < rhs.pin) {
-                return true;
-            }
+        bool operator==(const ConnectionComponent &rhs) const {
+            return (component == rhs.component) && (pin == rhs.pin);
         }
-        return false;
-    }
-};
 
-class Connection
-{
-    ConnectionComponent first;
-    std::optional<ConnectionComponent> second;
-    std::string bus;
-    std::vector<Attribute> attributes;
+        bool operator!=(const ConnectionComponent &rhs) const {
+            return !operator==(rhs);
+        }
 
-    std::vector<Value> firstWires;
-    std::optional<std::vector<Value>> secondWires;
-public:
-    Connection(ConnectionComponent first, std::optional<ConnectionComponent> second,
-               std::string bus, std::vector<Attribute> attributes,
-               std::vector<Value> firstWires, std::optional<std::vector<Value>> secondWires);
+        bool operator<(const ConnectionComponent &rhs) const {
+            if (component < rhs.component) {
+                return true;
+            } else if (component == rhs.component) {
+                if (pin < rhs.pin) {
+                    return true;
+                }
+            }
+            return false;
+        }
+    };
 
-    bool isConnecting(ConnectionComponent first);
-    bool isConnecting(ConnectionComponent first, std::string bus);
-    bool isConnecting(ConnectionComponent first, std::string bus, ConnectionComponent second);
-    bool isConnecting(ConnectionComponent first, ConnectionComponent second);
+    class Connection {
+        ConnectionComponent first;
+        std::optional<ConnectionComponent> second;
+        std::string bus;
+        std::vector<Attribute> attributes;
+
+        std::vector<Value> firstWires;
+        std::optional<std::vector<Value>> secondWires;
+    public:
+        Connection(ConnectionComponent first, std::optional<ConnectionComponent> second,
+                   std::string bus, std::vector<Attribute> attributes,
+                   std::vector<Value> firstWires, std::optional<std::vector<Value>> secondWires);
+
+        bool isConnecting(ConnectionComponent first);
+
+        bool isConnecting(ConnectionComponent first, std::string bus);
+
+        bool isConnecting(ConnectionComponent first, std::string bus, ConnectionComponent second);
+
+        bool isConnecting(ConnectionComponent first, ConnectionComponent second);
 
 
-    ConnectionComponent getComponent();
-    std::optional<ConnectionComponent> getSecondComponent();
+        ConnectionComponent getComponent();
 
-    std::string getBus();
+        std::optional<ConnectionComponent> getSecondComponent();
 
-    std::vector<Attribute> getAttributes();
+        std::string getBus();
 
-    std::vector<Value> getWires();
-    std::optional<std::vector<Value>> getSecondWires();
+        std::vector<Attribute> getAttributes();
 
-    Attribute getAttribute(std::string name);
-    bool hasAttribute(std::string name);
-};
+        std::vector<Value> getWires();
+
+        std::optional<std::vector<Value>> getSecondWires();
+
+        Attribute getAttribute(std::string name);
+
+        bool hasAttribute(std::string name);
+    };
 
 } // namespace domain
 

comdel/domain/connection_instance.cpp

@@ -0,0 +1,29 @@
+#include "connection_instance.h"
+
+namespace domain {
+
+
+    ConnectionInstance::ConnectionInstance(ComponentInstance *instance, std::vector<InstanceAttribute> attributes,
+                                           Connection connection)
+            : instance(instance), attributes(attributes), connection(connection) {}
+
+    InstanceAttribute ConnectionInstance::getAttribute(string attribute) {
+        for (auto &attr: attributes) {
+            if (attr.name == attribute) {
+                return attr;
+            }
+        }
+        throw std::exception();
+    }
+
+
+    BusConnectionInstance::BusConnectionInstance(ComponentInstance *instance, std::vector<InstanceAttribute> attributes,
+                                                 BusInstance *bus, Connection connection)
+            : ConnectionInstance(instance, attributes, connection), bus(bus) {}
+
+    DirectConnectionInstance::DirectConnectionInstance(ComponentInstance *instance, ComponentInstance *secondInstance,
+                                                       std::vector<InstanceAttribute> attributes, BusInstance *bus,
+                                                       Connection connection)
+            : ConnectionInstance(instance, attributes, connection), secondInstance(secondInstance), bus(bus) {}
+
+} // namespace domain

comdel/domain/connection_instance.h

@@ -0,0 +1,49 @@
+#ifndef DOMAIN_CONNECTION_INSTANCE_H
+#define DOMAIN_CONNECTION_INSTANCE_H
+
+#include "connection.h"
+#include "instance.h"
+
+namespace domain {
+
+    class ConnectionInstance {
+    public:
+        ComponentInstance *instance;
+        Connection connection;
+
+        virtual ~ConnectionInstance() = default;
+
+        std::vector<InstanceAttribute> attributes;
+
+        std::pair<int, int> start;
+        std::pair<int, int> end;
+
+        ConnectionInstance(ComponentInstance *instance, std::vector<InstanceAttribute> attributes,
+                           Connection connection);
+
+        InstanceAttribute getAttribute(string attribute);
+    };
+
+
+    class BusConnectionInstance : public ConnectionInstance {
+    public:
+        BusInstance *bus;
+
+        BusConnectionInstance(ComponentInstance *instance, std::vector<InstanceAttribute> attributes, BusInstance *bus,
+                              Connection connection);
+    };
+
+
+    class DirectConnectionInstance : public ConnectionInstance {
+    public:
+        BusInstance *bus;
+        ComponentInstance *secondInstance;
+
+        DirectConnectionInstance(ComponentInstance *instance, ComponentInstance *secondsInstance,
+                                 std::vector<InstanceAttribute> attributes, BusInstance *bus, Connection connection);
+    };
+
+
+} // namespace domain
+
+#endif // DOMAIN_CONNECTIONINSTANCE_H

comdel/domain/connectioninstance.cpp

@@ -1,28 +0,0 @@
-#include "connectioninstance.h"
-
-namespace domain {
-
-
-ConnectionInstance::ConnectionInstance(ComponentInstance *instance, std::vector<InstanceAttribute> attributes, Connection connection)
-    : instance(instance), attributes(attributes), connection(connection)
-{}
-
-InstanceAttribute ConnectionInstance::getAttribute(string attribute) {
-    for(auto& attr: attributes) {
-        if(attr.name == attribute) {
-            return attr;
-        }
-    }
-    throw std::exception();
-}
-
-
-BusConnectionInstance::BusConnectionInstance(ComponentInstance *instance, std::vector<InstanceAttribute> attributes, BusInstance *bus, Connection connection)
-    : ConnectionInstance(instance, attributes, connection), bus(bus)
-{}
-
-DirectConnectionInstance::DirectConnectionInstance(ComponentInstance *instance, ComponentInstance *secondInstance, std::vector<InstanceAttribute> attributes, BusInstance *bus, Connection connection)
-    : ConnectionInstance(instance, attributes, connection), secondInstance(secondInstance), bus(bus)
-{}
-
-} // namespace domain

comdel/domain/connectioninstance.h

@@ -1,50 +0,0 @@
-#ifndef DOMAIN_CONNECTION_INSTANCE_H
-#define DOMAIN_CONNECTION_INSTANCE_H
-
-#include "connection.h"
-#include "instance.h"
-#include "wireinstance.h"
-
-namespace domain {
-
-class ConnectionInstance
-{
-public:
-    ComponentInstance *instance;
-    Connection connection;
-
-    virtual ~ConnectionInstance() = default;
-
-    std::vector<InstanceAttribute> attributes;
-
-    std::pair<int, int> start;
-    std::pair<int, int> end;
-
-    ConnectionInstance(ComponentInstance *instance, std::vector<InstanceAttribute> attributes, Connection connection);
-
-    InstanceAttribute getAttribute(string attribute);
-};
-
-
-class BusConnectionInstance: public ConnectionInstance
-{
-public:
-    BusInstance *bus;
-
-    BusConnectionInstance(ComponentInstance *instance, std::vector<InstanceAttribute> attributes, BusInstance *bus, Connection connection);
-};
-
-
-class DirectConnectionInstance: public ConnectionInstance
-{
-public:
-    BusInstance *bus;
-    ComponentInstance *secondInstance;
-
-    DirectConnectionInstance(ComponentInstance *instance, ComponentInstance *secondsInstance, std::vector<InstanceAttribute> attributes, BusInstance *bus, Connection connection);
-};
-
-
-} // namespace domain
-
-#endif // DOMAIN_CONNECTIONINSTANCE_H

comdel/domain/display.cpp

@@ -2,6 +2,172 @@
 
 namespace domain {
 
-Display::Display(std::vector<ui::Item> items): items(items) {}
+    Display::Display(std::vector<ui::Item> items) : items(items) {}
 
+    void Display::render(QGraphicsItemGroup *group) {
+        for (auto &item: items) {
+            item.render(group);
+        }
+    }
+
+    void Display::comdel(std::ostream &buffer, int x, int y, int size) {
+        for (auto &item: items) {
+            item.comdel(buffer, x, y, size);
+        }
+    }
+
+    void ui::Rect::render(QGraphicsItemGroup *group) {
+        group->addToGroup(new QGraphicsRectItem(x, y, w, h));
+    }
+
+    void ui::Rect::comdel(std::ostream &buffer, int x, int y) {
+        buffer << "\t\trectangle {\n";
+        buffer << "\t\t\tx: " << (this->x + x) << "; y: " << (this->y + y) << ";\n";
+        buffer << "\t\t\tw: " << w << "; h: " << h << ";\n";
+        buffer << "\t\t}\n\n";
+    }
+
+    void ui::Line::render(QGraphicsItemGroup *group) {
+        group->addToGroup(new QGraphicsLineItem(x1, y1, x2, y2));
+    }
+
+    void ui::Line::comdel(std::ostream &buffer, int x, int y) {
+        buffer << "\t\tline {\n";
+        buffer << "\t\t\tx1: " << (x1 + x) << "; y1: " << (y1 + y) << ";\n";
+        buffer << "\t\t\tx2: " << (x2 + x) << "; y2: " << (y2 + y) << ";\n";
+        buffer << "\t\t}\n\n";
+    }
+
+    void ui::Bus::render(QGraphicsItemGroup *group, int size) {
+        if (orientation == HORIZONTAL) {
+            group->addToGroup(new QGraphicsRectItem(x, y, size, h));
+        } else {
+            group->addToGroup(new QGraphicsRectItem(x, y, w, size));
+        }
+    }
+
+    int ui::Bus::getDefaultSize() {
+        if (orientation == HORIZONTAL) {
+            return w;
+        } else {
+            return h;
+        }
+    }
+
+    void ui::Bus::comdel(std::ostream &buffer, int x, int y, int size) {
+        buffer << "\t\trectangle {\n";
+        buffer << "\t\t\tx: " << (this->x + x) << "; y: " << (this->y + y) << ";\n";
+        if (orientation == HORIZONTAL) {
+            buffer << "\t\t\tw: " << size << "; h: " << h << ";\n";
+        } else {
+            buffer << "\t\t\tw: " << w << "; h: " << size << ";\n";
+        }
+        buffer << "\t\t}\n\n";
+    }
+
+    void ui::Pin::renderIn(QGraphicsItemGroup *group) {
+        QPolygon polygon;
+
+        switch (orientation) {
+            case PinOrientation::TOP:
+                polygon << QPoint(x, y) << QPoint(x, y + h) << QPoint(x + w, y + h) << QPoint(x + w, y)
+                        << QPoint(x + w / 2, y + h / 2);
+                break;
+            case PinOrientation::BOTTOM:
+                polygon << QPoint(x, y) << QPoint(x, y + h) << QPoint(x + w / 2, y + h / 2)
+                        << QPoint(x + w, y + h) << QPoint(x + w, y);
+                break;
+            case PinOrientation::LEFT:
+                polygon << QPoint(x, y) << QPoint(x + w / 2, y + h / 2) << QPoint(x, y + h)
+                        << QPoint(x + w, y + h) << QPoint(x + w, y);
+                break;
+            case PinOrientation::RIGHT:
+                polygon << QPoint(x, y) << QPoint(x, y + h) << QPoint(x + w, y + h)
+                        << QPoint(x + w / 2, y + h / 2) << QPoint(x + w, y);
+                break;
+        }
+        group->addToGroup(new QGraphicsPolygonItem(polygon));
+    }
+
+    void ui::Pin::renderOut(QGraphicsItemGroup *group) {
+        QPolygon polygon;
+
+        switch (orientation) {
+            case PinOrientation::TOP:
+                polygon << QPoint(x, y + h / 2) << QPoint(x, y + h) << QPoint(x + w, y + h)
+                        << QPoint(x + w, y + h / 2) << QPoint(x + w / 2, y);
+                break;
+            case PinOrientation::BOTTOM:
+                polygon << QPoint(x, y) << QPoint(x, y + h / 2) << QPoint(x + w / 2, y + h)
+                        << QPoint(x + w, y + h / 2) << QPoint(x + w, y);
+                break;
+            case PinOrientation::LEFT:
+                polygon << QPoint(x + w, y) << QPoint(x + w / 2, y) << QPoint(x, y + h / 2)
+                        << QPoint(x + w / 2, y + h) << QPoint(x + w, y + w);
+                break;
+            case PinOrientation::RIGHT:
+                polygon << QPoint(x, y) << QPoint(x, y + h) << QPoint(x + w / 2, y + h)
+                        << QPoint(x + w, y + h / 2) << QPoint(x + w / 2, y);
+                break;
+        }
+        group->addToGroup(new QGraphicsPolygonItem(polygon));
+    }
+
+    void ui::Pin::renderInOut(QGraphicsItemGroup *group) {
+        group->addToGroup(new QGraphicsRectItem(x, y, w, h));
+    }
+
+    void ui::Pin::render(QGraphicsItemGroup *group) {
+        switch (pinType) {
+            case PinType::IN:
+                renderIn(group);
+                break;
+            case PinType::OUT:
+                renderOut(group);
+                break;
+            case PinType::IN_OUT:
+                renderInOut(group);
+                break;
+        }
+    }
+
+    int ui::Pin::getConnectionX() {
+        switch (orientation) {
+            case ui::PinOrientation::TOP:
+            case ui::PinOrientation::BOTTOM:
+                return x + w / 2;
+            case ui::PinOrientation::LEFT:
+                return x;
+            case ui::PinOrientation::RIGHT:
+                return x + w;
+        }
+        return 0;
+    }
+
+    int ui::Pin::getConnectionY() {
+        switch (orientation) {
+            case ui::PinOrientation::LEFT:
+            case ui::PinOrientation::RIGHT:
+                return y + h / 2;
+            case ui::PinOrientation::TOP:
+                return y;
+            case ui::PinOrientation::BOTTOM:
+                return y + h;
+        }
+        return 0;
+    }
+
+    void ui::Item::render(QGraphicsItemGroup *group, int size) {
+        if (rect) rect->render(group);
+        if (line) line->render(group);
+        if (pin) pin->render(group);
+        if (bus) bus->render(group, size);
+    }
+
+    void ui::Item::comdel(std::ostream &buffer, int x, int y, int size) {
+        if (rect) rect->comdel(buffer, x, y);
+        if (line) line->comdel(buffer, x, y);
+        // pins aren't exported
+        if (bus) bus->comdel(buffer, x, y, size);
+    }
 } // namespace domain

comdel/domain/display.h

@@ -8,237 +8,109 @@
 
 namespace domain {
 
-namespace ui {
+    namespace ui {
 
-class Rect {
-public:
-    int x, y, w, h;
+        class Rect {
+        public:
+            int x, y, w, h;
 
-    Rect(int x, int y, int w, int h): x(x), y(y), w(w), h(h) {}
+            Rect(int x, int y, int w, int h) : x(x), y(y), w(w), h(h) {}
+
+            void render(QGraphicsItemGroup *group);
+
+            void comdel(std::ostream &buffer, int x, int y);
+
+        };
+
+        class Line {
+        public:
+            int x1, y1, x2, y2;
+
+            Line(int x1, int y1, int x2, int y2) : x1(x1), y1(y1), x2(x2), y2(y2) {}
+
+            void render(QGraphicsItemGroup *group);
+
+            void comdel(std::ostream &buffer, int x, int y);
+        };
+
+        enum PinType {
+            IN, OUT, IN_OUT
+        };
+        enum PinOrientation {
+            LEFT, RIGHT, TOP, BOTTOM
+        };
+        enum BusOrientation {
+            VERTICAL, HORIZONTAL
+        };
+
+        class Bus {
+        public:
+            int x, y, w, h;
+            BusOrientation orientation;
+
+            Bus(int x, int y, int w, int h, BusOrientation orientation) : x(x), y(y), w(w), h(h),
+                                                                          orientation(orientation) {}
+
+            void render(QGraphicsItemGroup *group, int size);
+
+            int getDefaultSize();
+
+            void comdel(std::ostream &buffer, int x, int y, int size);
+
+        };
+
+        class Pin {
+        public:
+            PinOrientation orientation;
+            PinType pinType;
+            int x, y, w, h;
+
+            Pin(int x, int y, int w, int h, PinOrientation orientation, PinType pinType) : x(x), y(y), w(w), h(h),
+                                                                                           orientation(orientation),
+                                                                                           pinType(pinType) {}
+
+        public:
+            void render(QGraphicsItemGroup *group);
+
+            int getConnectionX();
+            int getConnectionY();
+
+        private:
+            void renderIn(QGraphicsItemGroup *group);
+            void renderOut(QGraphicsItemGroup *group);
+            void renderInOut(QGraphicsItemGroup *group);
+        };
+
+
+        class Item {
+        public:
+            Item() : rect(std::nullopt), line(std::nullopt), pin(std::nullopt), bus(std::nullopt) {}
+
+            std::optional<Rect> rect = std::nullopt;
+            std::optional<Line> line = std::nullopt;
+            std::optional<Pin> pin = std::nullopt;
+            std::optional<Bus> bus = std::nullopt;
+
+            void render(QGraphicsItemGroup *group, int size = 0);
+            void comdel(std::ostream &buffer, int x, int y, int size = 0);
+        };
 
-    void render(QGraphicsItemGroup *group) {
-        group->addToGroup(new QGraphicsRectItem(x,y,w,h));
     }
 
-    void comdel(std::ostream &buffer, int x, int y) {
-        buffer << "\t\trectangle {\n";
-        buffer << "\t\t\tx: " << (this->x + x) << "; y: " << (this->y + y) << ";\n";
-        buffer << "\t\t\tw: " << w << "; h: " << h << ";\n";
-        buffer << "\t\t}\n\n";
-    }
+    class Display {
+    public:
 
-};
+        Display(std::vector<ui::Item> items);
 
-class Line {
-public:
-    int x1, y1, x2, y2;
+        void render(QGraphicsItemGroup *group);
 
-    Line(int x1, int y1, int x2, int y2): x1(x1), y1(y1), x2(x2), y2(y2) {}
+        void comdel(std::ostream &buffer, int x, int y, int size = 0);
 
-    void render(QGraphicsItemGroup *group) {
-        group->addToGroup(new QGraphicsLineItem(x1, y1, x2, y2));
-    }
+        std::vector<ui::Item> &getItems() { return items; }
 
-    void comdel(std::ostream &buffer, int x, int y) {
-        buffer << "\t\tline {\n";
-        buffer << "\t\t\tx1: " << (x1 + x) << "; y1: " << (y1 + y) << ";\n";
-        buffer << "\t\t\tx2: " << (x2 + x) << "; y2: " << (y2 + y) << ";\n";
-        buffer << "\t\t}\n\n";
-    }
-};
-
-enum PinOrientation {
-    LEFT, RIGHT, TOP, BOTTOM
-};
-enum BusOrientation {
-    VERTICAL, HORIZONTAL
-};
-
-enum PinType {
-    IN, OUT, IN_OUT
-};
-
-
-class Bus {
-public:
-    int x, y, w, h;
-    BusOrientation orientation;
-
-    Bus(int x, int y, int w, int h, BusOrientation orientation): x(x), y(y), w(w), h(h), orientation(orientation) {}
-
-    void render(QGraphicsItemGroup *group, int size) {
-        if(orientation == HORIZONTAL) {
-            group->addToGroup(new QGraphicsRectItem(x,y,size, h));
-        } else {
-            group->addToGroup(new QGraphicsRectItem(x,y,w,size));
-        }
-    }
-
-    int getDefaultSize() {
-       if(orientation == HORIZONTAL) {
-           return w;
-       }  else {
-           return h;
-       }
-    }
-
-    void comdel(std::ostream &buffer, int x, int y, int size) {
-        buffer << "\t\trectangle {\n";
-        buffer << "\t\t\tx: " << (this->x + x) << "; y: " << (this->y + y) << ";\n";
-        if(orientation == HORIZONTAL) {
-            buffer << "\t\t\tw: " << size << "; h: " << h << ";\n";
-        } else {
-            buffer << "\t\t\tw: " << w << "; h: " << size << ";\n";
-        }
-        buffer << "\t\t}\n\n";
-    }
-
-};
-
-
-class Pin {
-public:
-    PinOrientation orientation;
-    PinType pinType;
-    int x, y, w, h;
-
-    Pin(int x, int y, int w, int h, PinOrientation orientation, PinType pinType): x(x), y(y), w(w), h(h), orientation(orientation), pinType(pinType) {}
-
-    void renderIn(QGraphicsItemGroup *group) {
-        QPolygon polygon;
-
-        switch (orientation) {
-            case PinOrientation::TOP:
-                polygon << QPoint(x, y) << QPoint(x, y+h) << QPoint(x+w, y+h)  << QPoint(x+w, y) << QPoint(x+w/2, y+h/2);
-                break;
-            case PinOrientation::BOTTOM:
-                polygon << QPoint(x, y) << QPoint(x, y+h) << QPoint(x+w/2, y+h/2) << QPoint(x+w, y+h)  << QPoint(x+w, y);
-                break;
-            case PinOrientation::LEFT:
-                polygon << QPoint(x, y) << QPoint(x+w/2, y+h/2) << QPoint(x, y+h) << QPoint(x+w, y+h)  << QPoint(x+w, y);
-                break;
-            case PinOrientation::RIGHT:
-                polygon << QPoint(x, y) << QPoint(x, y+h) << QPoint(x+w, y+h) << QPoint(x+w/2, y+h/2) << QPoint(x+w, y);
-                break;
-        }
-        group->addToGroup(new QGraphicsPolygonItem(polygon));
-    }
-
-    void renderOut(QGraphicsItemGroup *group) {
-        QPolygon polygon;
-
-        switch (orientation) {
-            case PinOrientation::TOP:
-                polygon << QPoint(x, y+h/2) << QPoint(x, y+h) << QPoint(x+w, y+h) << QPoint(x+w, y+h/2) << QPoint(x+w/2, y);
-                break;
-            case PinOrientation::BOTTOM:
-                polygon << QPoint(x, y) << QPoint(x, y+h/2) << QPoint(x+w/2, y+h) << QPoint(x+w, y+h/2) << QPoint(x+w, y);
-                break;
-            case PinOrientation::LEFT:
-                polygon << QPoint(x+w, y) << QPoint(x+w/2, y) << QPoint(x, y+h/2) << QPoint(x+w/2, y+h) << QPoint(x+w, y+w);
-                break;
-            case PinOrientation::RIGHT:
-                polygon << QPoint(x, y) << QPoint(x, y+h) << QPoint(x+w/2, y+h) << QPoint(x+w, y+h/2) << QPoint(x+w/2, y);
-                break;
-        }
-        group->addToGroup(new QGraphicsPolygonItem(polygon));
-    }
-
-    void renderInOut(QGraphicsItemGroup *group) {
-        group->addToGroup(new QGraphicsRectItem(x, y ,w, h));
-    }
-
-    void render(QGraphicsItemGroup *group) {
-        switch (pinType) {
-            case PinType::IN:
-                renderIn(group);
-                break;
-            case PinType::OUT:
-                renderOut(group);
-                break;
-            case PinType::IN_OUT:
-                renderInOut(group);
-                break;
-        }
-    }
-
-    int getConnectionX() {
-        switch (orientation) {
-            case ui::PinOrientation::TOP:
-            case ui::PinOrientation::BOTTOM:
-                return x+w/2;
-            case ui::PinOrientation::LEFT:
-                return x;
-            case ui::PinOrientation::RIGHT:
-                return x+w;
-        }
-        return 0;
-    }
-
-    int getConnectionY() {
-        switch (orientation) {
-            case ui::PinOrientation::LEFT:
-            case ui::PinOrientation::RIGHT:
-                return y+h/2;
-            case ui::PinOrientation::TOP:
-                return y;
-            case ui::PinOrientation::BOTTOM:
-                return y+h;
-        }
-        return 0;
-    }
-};
-
-
-class Item {
-public:
-    Item(): rect(std::nullopt), line(std::nullopt), pin(std::nullopt), bus(std::nullopt) {}
-
-    void render(QGraphicsItemGroup *group, int size = 0) {
-        if(rect) rect->render(group);
-        if(line) line->render(group);
-        if(pin) pin->render(group);
-        if(bus) bus->render(group, size);
-    }
-
-    std::optional<Rect> rect = std::nullopt;
-    std::optional<Line> line = std::nullopt;
-    std::optional<Pin> pin = std::nullopt;
-    std::optional<Bus> bus = std::nullopt;
-
-    void comdel(std::ostream &buffer, int x, int y, int size = 0) {
-        if(rect) rect->comdel(buffer, x, y);
-        if(line) line->comdel(buffer, x, y);
-        // pins aren't exported
-        if(bus) bus->comdel(buffer, x, y, size);
-    }
-};
-
-}
-
-class Display
-{
-public:
-
-    Display(std::vector<ui::Item> items);
-
-    void render(QGraphicsItemGroup *group) {
-        for(auto &item: items) {
-            item.render(group);
-        }
-    }
-
-    void comdel(std::ostream &buffer, int x, int y, int size = 0) {
-        for(auto &item: items) {
-            item.comdel(buffer, x, y, size);
-        }
-    }
-
-    std::vector<ui::Item>& getItems() {return items;}
-
-private:
-    std::vector<ui::Item> items;
-};
+    private:
+        std::vector<ui::Item> items;
+    };
 
 } // namespace domain
 

comdel/domain/function_signature.cpp

@@ -0,0 +1,166 @@
+#include <map>
+#include <utility>
+#include "function_signature.h"
+
+namespace domain {
+
+    class DivisibleValidator : public FunctionValidator {
+    public:
+        DivisibleValidator() : FunctionValidator("divisible", {Value::INT, Value::INT}) {}
+
+        bool validate(std::vector<Value> values) override {
+            if (validateSignature(values)) {
+                long long first = values[0].asInt();
+                long long second = values[1].asInt();
+                return (first % second) == 0;
+            }
+            return false;
+        }
+
+        void clear() override {}
+    };
+
+    class LessThenValidator : public FunctionValidator {
+    public:
+        LessThenValidator() : FunctionValidator("less_then", {Value::INT, Value::INT}) {}
+
+        bool validate(std::vector<Value> values) override {
+            if (validateSignature(values)) {
+                long long first = values[0].asInt();
+                long long second = values[1].asInt();
+                return first < second;
+            }
+            return false;
+        }
+
+        void clear() override {}
+    };
+
+    class GreaterThenValidator : public FunctionValidator {
+    public:
+        GreaterThenValidator() : FunctionValidator("greater_then", {Value::INT, Value::INT}) {}
+
+        bool validate(std::vector<Value> values) override {
+            if (validateSignature(values)) {
+                long long first = values[0].asInt();
+                long long second = values[1].asInt();
+                return first > second;
+            }
+            return false;
+        }
+
+        void clear() override {}
+    };
+
+
+    class ContainsAddressValidator : public FunctionValidator {
+    public:
+        ContainsAddressValidator() : FunctionValidator("contains_address", {Value::ADDRESS_SPACE, Value::INT}) {}
+
+        bool validate(std::vector<Value> values) override {
+            if (validateSignature(values)) {
+                AddressSpace space = values[0].asAddressSpace();
+                long long address = values[1].asInt();
+                return space.contains(address);
+            }
+            return false;
+        }
+
+        void clear() override {}
+    };
+
+
+    class ContainsValidator : public FunctionValidator {
+    public:
+        ContainsValidator() : FunctionValidator("contains", {Value::ADDRESS_SPACE, Value::INT, Value::INT}) {}
+
+        bool validate(std::vector<Value> values) override {
+            if (validateSignature(values)) {
+                AddressSpace space = values[0].asAddressSpace();
+                long long start = values[1].asInt();
+                long long size = values[1].asInt();
+                return space.contains(start, start + size);
+            }
+            return false;
+        }
+
+        void clear() override {}
+    };
+
+
+    class UniqueValidator : public FunctionValidator {
+
+    private:
+        std::map<std::string, std::vector<std::pair<long long int, long long int>>> spaces;
+
+        bool overlaps(long long int start1, long long int end1, long long int start2, long long int end2) {
+            return std::max((long long int) 0, std::min(end1, end2) - std::max(start1, start2)) > 0;
+        }
+
+    public:
+        UniqueValidator() : FunctionValidator("unique", {Value::ADDRESS_SPACE, Value::INT, Value::INT}) {}
+
+        bool validate(std::vector<Value> values) override {
+            if (validateSignature(values)) {
+                std::string space = values[0].asAddressSpace().getName();
+                long long int start = values[1].asInt();
+                long long int end = start + values[2].asInt();
+                if (spaces.count(space) == 0) {
+                    spaces.insert(std::make_pair(space, std::vector<std::pair<long long int, long long int>>{}));
+                }
+                for (auto &s: spaces[space]) {
+                    if (overlaps(s.first, s.second, start, end)) {
+                        return false;
+                    }
+                }
+                spaces[space].push_back(std::make_pair(start, end));
+                return true;
+            }
+            return false;
+        }
+
+        void clear() override {
+            spaces.clear();
+        }
+    };
+
+
+    std::vector<FunctionValidator *> getSupportedValidators() {
+        std::vector<FunctionValidator *> validators;
+
+        validators.push_back(new DivisibleValidator());
+        validators.push_back(new LessThenValidator());
+        validators.push_back(new GreaterThenValidator());
+        validators.push_back(new ContainsAddressValidator());
+        validators.push_back(new ContainsValidator());
+        validators.push_back(new UniqueValidator());
+
+        return validators;
+    }
+
+
+    FunctionValidator::FunctionValidator(std::string name, std::vector<Value::ValueType> signature)
+        : name(std::move(name)), signature(std::move(signature)) {}
+
+    std::string FunctionValidator::getName() {
+        return name;
+    }
+
+    std::vector<Value::ValueType> FunctionValidator::getSignature() {
+        return signature;
+    }
+
+    bool FunctionValidator::validateSignature(std::vector<Value> _signature) {
+        if (this->signature.size() != _signature.size()) {
+            return false;
+        }
+
+        for (int i = 0; i < this->signature.size(); i++) {
+            if (this->signature[i] != _signature[i].getType()) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+} // namespace domain

comdel/domain/function_signature.h

@@ -0,0 +1,36 @@
+#ifndef DOMAIN_FUNCTION_VALIDATOR_H
+#define DOMAIN_FUNCTION_VALIDATOR_H
+
+#include<functional>
+#include<vector>
+
+#include "value.h"
+
+namespace domain {
+
+    class FunctionValidator {
+    private:
+        std::string name;
+        std::vector<Value::ValueType> signature;
+
+    protected:
+        FunctionValidator(std::string name, std::vector<Value::ValueType> signature);
+
+    public:
+
+        std::string getName();
+
+        std::vector<Value::ValueType> getSignature();
+
+        bool validateSignature(std::vector<Value> signature);
+
+        virtual bool validate(std::vector<Value> values) = 0;
+
+        virtual void clear() = 0;
+    };
+
+    std::vector<FunctionValidator *> getSupportedValidators();
+
+} // namespace domain
+
+#endif // DOMAIN_FUNCTION_VALIDATOR_H

comdel/domain/functionsignature.cpp

@@ -1,138 +0,0 @@
-#include <map>
-#include "functionsignature.h"
-
-namespace domain {
-
-class DivisibleValidator: public FunctionValidator {
-public:
-    DivisibleValidator(): FunctionValidator("divisible", {Value::INT, Value::INT}) {}
-
-    bool validate(std::vector<Value> values) override {
-        if(validateSignature(values)) {
-            long long first = values[0].asInt();
-            long long second = values[1].asInt();
-            return (first % second) == 0;
-        }
-        return false;
-    }
-    void clear() override {}
-};
-
-class LessThenValidator: public FunctionValidator {
-public:
-    LessThenValidator(): FunctionValidator("less_then", {Value::INT, Value::INT}) {}
-
-    bool validate(std::vector<Value> values) override {
-        if(validateSignature(values)) {
-            long long first = values[0].asInt();
-            long long second = values[1].asInt();
-            return first < second;
-        }
-        return false;
-    }
-    void clear() override {}
-};
-
-class GreaterThenValidator: public FunctionValidator {
-public:
-    GreaterThenValidator(): FunctionValidator("greater_then", {Value::INT, Value::INT}) {}
-
-    bool validate(std::vector<Value> values) override {
-        if(validateSignature(values)) {
-            long long first = values[0].asInt();
-            long long second = values[1].asInt();
-            return first > second;
-        }
-        return false;
-    }
-    void clear() override {}
-};
-
-
-class ContainsAddressValidator: public FunctionValidator {
-public:
-    ContainsAddressValidator(): FunctionValidator("contains_address", {Value::ADDRESS_SPACE, Value::INT}) {}
-
-    bool validate(std::vector<Value> values) override {
-        if(validateSignature(values)) {
-            AddressSpace space = values[0].asAddressSpace();
-            long long address = values[1].asInt();
-            return space.contains(address);
-        }
-        return false;
-    }
-    void clear() override {}
-};
-
-
-class ContainsValidator: public FunctionValidator {
-public:
-    ContainsValidator(): FunctionValidator("contains", {Value::ADDRESS_SPACE, Value::INT, Value::INT}) {}
-
-    bool validate(std::vector<Value> values) override {
-        if(validateSignature(values)) {
-            AddressSpace space = values[0].asAddressSpace();
-            long long start = values[1].asInt();
-            long long size = values[1].asInt();
-            return space.contains(start, start + size);
-        }
-        return false;
-    }
-    void clear() override {}
-};
-
-
-
-
-class UniqueValidator: public FunctionValidator {
-
-private:
-    std::map<std::string, std::vector<std::pair<long long int, long long int>>> spaces;
-
-    bool overlaps(long long int start1, long long int end1, long long int start2, long long int end2) {
-        return std::max((long long int)0, std::min(end1, end2) - std::max(start1, start2)) > 0;
-    }
-
-public:
-    UniqueValidator(): FunctionValidator("unique", {Value::ADDRESS_SPACE, Value::INT, Value::INT}) {}
-
-    bool validate(std::vector<Value> values) override {
-        if(validateSignature(values)) {
-            std::string space = values[0].asAddressSpace().getName();
-            long long int start = values[1].asInt();
-            long long int end = start + values[2].asInt();
-            if(spaces.count(space) == 0) {
-                spaces.insert(std::make_pair(space, std::vector<std::pair<long long int, long long int>>{}));
-            }
-            for(auto& s: spaces[space]) {
-                if(overlaps(s.first, s.second, start, end)) {
-                    return false;
-                }
-            }
-            spaces[space].push_back(std::make_pair(start, end));
-            return true;
-        }
-        return false;
-    }
-    void clear() override {
-        spaces.clear();
-    }
-};
-
-
-std::vector<FunctionValidator*> getSupportedValidators() {
-    std::vector<FunctionValidator*> validators;
-
-    validators.push_back(new DivisibleValidator());
-    validators.push_back(new LessThenValidator());
-    validators.push_back(new GreaterThenValidator());
-    validators.push_back(new ContainsAddressValidator());
-    validators.push_back(new ContainsValidator());
-    validators.push_back(new UniqueValidator());
-
-    return validators;
-}
-
-
-
-} // namespace domain

comdel/domain/functionsignature.h

@@ -1,53 +0,0 @@
-#ifndef DOMAIN_FUNCTION_VALIDATOR_H
-#define DOMAIN_FUNCTION_VALIDATOR_H
-
-#include<functional>
-#include<vector>
-
-#include "value.h"
-
-namespace domain {
-
-class FunctionValidator {
-private:
-    std::string name;
-    std::vector<Value::ValueType> signature;
-
-protected:
-    FunctionValidator(std::string name, std::vector<Value::ValueType> signature) {
-        this->name = name;
-        this->signature = signature;
-    }
-
-public:
-
-    std::string getName() {
-        return name;
-    }
-
-    std::vector<Value::ValueType> getSignature() {
-        return signature;
-    }
-
-    bool validateSignature(std::vector<Value> signature) {
-        if(this->signature.size() != signature.size()) {
-            return false;
-        }
-
-        for(int i=0; i<this->signature.size(); i++) {
-            if(this->signature[i] != signature[i].getType()) {
-                return false;
-            }
-        }
-        return true;
-    }
-
-    virtual bool validate(std::vector<Value> values) = 0;
-    virtual void clear() = 0;
-};
-
-std::vector<FunctionValidator*> getSupportedValidators();
-
-} // namespace domain
-
-#endif // DOMAIN_FUNCTION_VALIDATOR_H

comdel/domain/instance.cpp

@@ -2,19 +2,18 @@
 
 namespace domain {
 
-BusInstance::BusInstance(std::string name, std::pair<int, int> position, Bus bus, int size)
-    : name(name), position(position), bus(bus), size(size)
-{
-    if(size < 0 && bus.getDisplayBus().has_value()) {
-        this->size = bus.getDisplayBus()->getDefaultSize();
+    BusInstance::BusInstance(std::string name, std::pair<int, int> position, Bus bus, int size)
+            : name(name), position(position), bus(bus), size(size) {
+        if (size < 0 && bus.getDisplayBus().has_value()) {
+            this->size = bus.getDisplayBus()->getDefaultSize();
+        }
     }
-}
 
-    BusInstance::BusInstance(std::string name, Bus bus): name(name), bus(bus), position(0,0), size(0) {}
+    BusInstance::BusInstance(std::string name, Bus bus) : name(name), bus(bus), position(0, 0), size(0) {}
 
-    ComponentInstance::ComponentInstance(std::string name, std::vector<InstanceAttribute> attributes, std::pair<int, int> position, Component component)
-    : name(name), attributes(std::move(attributes)), position(position), component(component)
-{}
+    ComponentInstance::ComponentInstance(std::string name, std::vector<InstanceAttribute> attributes,
+                                         std::pair<int, int> position, Component component)
+            : name(name), attributes(std::move(attributes)), position(position), component(component) {}
 
 
 } // namespace domain

comdel/domain/instance.h

@@ -3,44 +3,41 @@
 
 #include "bus.h"
 #include "component.h"
-#include "instanceattribute.h"
+#include "instance_attribute.h"
 
 #include <string>
 #include <vector>
 
 
-
 namespace domain {
 
-class BusInstance
-{
-public:
-    std::string name;
-    std::pair<int, int> position;
+    class BusInstance {
+    public:
+        std::string name;
+        std::pair<int, int> position;
 
-    Bus bus;
-    int size;
+        Bus bus;
+        int size;
 
-    BusInstance(std::string name, Bus bus);
+        BusInstance(std::string name, Bus bus);
 
-    BusInstance(std::string name, std::pair<int, int> position, Bus bus, int size = -1);
+        BusInstance(std::string name, std::pair<int, int> position, Bus bus, int size = -1);
 
-    virtual ~BusInstance() = default;
-};
+        virtual ~BusInstance() = default;
+    };
 
-class ComponentInstance
-{
-public:
-    std::string name;
-    std::vector<InstanceAttribute> attributes;
-    std::pair<int, int> position;
+    class ComponentInstance {
+    public:
+        std::string name;
+        std::vector<InstanceAttribute> attributes;
+        std::pair<int, int> position;
 
-    Component component;
+        Component component;
 
-    ComponentInstance(std::string name, std::vector<InstanceAttribute> attributes, std::pair<int, int> position, Component component);
+        ComponentInstance(std::string name, std::vector<InstanceAttribute> attributes, std::pair<int, int> position, Component component);
 
-    virtual ~ComponentInstance() = default;
-};
+        virtual ~ComponentInstance() = default;
+    };
 
 } // namespace domain
 

comdel/domain/instance_attribute.cpp

@@ -0,0 +1,8 @@
+#include "instance_attribute.h"
+
+namespace domain {
+
+    InstanceAttribute::InstanceAttribute(std::string name, Value value, Attribute attribute)
+            : name(name), value(value), attribute(attribute) {}
+
+} // namespace domain

comdel/domain/instance_attribute.h

@@ -0,0 +1,25 @@
+#ifndef DOMAIN_INSTANCE_ATTRIBUTE_H
+#define DOMAIN_INSTANCE_ATTRIBUTE_H
+
+#include "attribute.h"
+#include "value.h"
+
+#include <string>
+
+
+namespace domain {
+
+    class InstanceAttribute {
+    public:
+        InstanceAttribute(std::string name, Value value, Attribute attribute);
+
+        std::string name;
+        Value value;
+        Attribute attribute;
+
+        ~InstanceAttribute() = default;
+    };
+
+} // namespace domain
+
+#endif // DOMAIN_INSTANCE_ATTRIBUTE_H

comdel/domain/instanceattribute.cpp

@@ -1,9 +0,0 @@
-#include "instanceattribute.h"
-
-namespace domain {
-
-InstanceAttribute::InstanceAttribute(std::string name, Value value, Attribute attribute)
-    : name(name), value(value), attribute(attribute)
-{}
-
-} // namespace domain

comdel/domain/instanceattribute.h

@@ -1,27 +0,0 @@
-#ifndef DOMAIN_INSTANCE_ATTRIBUTE_H
-#define DOMAIN_INSTANCE_ATTRIBUTE_H
-
-#include "attribute.h"
-#include "value.h"
-
-#include <string>
-
-
-
-namespace domain {
-
-class InstanceAttribute
-{
-public:
-    InstanceAttribute(std::string name, Value value, Attribute attribute);
-
-    std::string name = "";
-    Value value;
-    Attribute attribute;
-
-    ~InstanceAttribute() = default;
-};
-
-} // namespace domain
-
-#endif // DOMAIN_INSTANCE_ATTRIBUTE_H

comdel/domain/library.cpp

@@ -2,116 +2,131 @@
 
 namespace domain {
 
-Library::Library(string name, string libraryInfo, string header, string componentDirectory, std::optional<std::string> componentHeader,
-        vector<AddressSpace> addressSpaces, vector<Component> components, vector<Bus> buses, vector<Connection> connections, map<string, string> messages)
-    : name(name), libraryInfo(libraryInfo), header(header), componentDirectory(componentDirectory), componentHeader(componentHeader), addressSpaces(addressSpaces),
-      components(components), buses(buses), connections(connections), messages(messages)
-{}
+    Library::Library(string name, string libraryInfo, string header, string componentDirectory,
+                     std::optional<std::string> componentHeader,
+                     vector<AddressSpace> addressSpaces, vector<Component> components, vector<Bus> buses,
+                     vector<Connection> connections, map<string, string> messages)
+            : name(name), libraryInfo(libraryInfo), header(header), componentDirectory(componentDirectory),
+              componentHeader(componentHeader), addressSpaces(addressSpaces),
+              components(components), buses(buses), connections(connections), messages(messages) {}
 
-std::string Library::getName() {
-    return name;
-}
-std::string Library::getLibraryInfo() {
-    return libraryInfo;
-}
-std::string Library::getHeader() {
-    return header;
-}
-std::string Library::getComponentDirectory() {
-    return componentDirectory;
-}
-std::optional<std::string> Library::getComponentHeader() {
-    return componentHeader;
-}
-
-std::vector<AddressSpace> Library::getAddressSpaces() {
-    return addressSpaces;
-}
-std::vector<Component> Library::getComponents() {
-    return components;
-}
-std::vector<Bus> Library::getBuses() {
-    return buses;
-}
-std::vector<Connection> Library::getConnections() {
-    return connections;
-}
-
-std::map<std::string, std::string> Library::getMessages() {
-    return messages;
-}
-
-bool Library::hasComponent(std::string name) {
-    for(uint i=0; i<components.size(); i++) {
-        if(components[i].getName() == name) {
-            return true;
-        }
+    std::string Library::getName() {
+        return name;
     }
-    return false;
-}
-bool Library::hasBus(std::string name) {
-    for(uint i=0; i<buses.size(); i++) {
-        if(buses[i].getName() == name) {
-            return true;
+
+    std::string Library::getLibraryInfo() {
+        return libraryInfo;
+    }
+
+    std::string Library::getHeader() {
+        return header;
+    }
+
+    std::string Library::getComponentDirectory() {
+        return componentDirectory;
+    }
+
+    std::optional<std::string> Library::getComponentHeader() {
+        return componentHeader;
+    }
+
+    std::vector<AddressSpace> Library::getAddressSpaces() {
+        return addressSpaces;
+    }
+
+    std::vector<Component> Library::getComponents() {
+        return components;
+    }
+
+    std::vector<Bus> Library::getBuses() {
+        return buses;
+    }
+
+    std::vector<Connection> Library::getConnections() {
+        return connections;
+    }
+
+    std::map<std::string, std::string> Library::getMessages() {
+        return messages;
+    }
+
+    bool Library::hasComponent(std::string name) {
+        for (uint i = 0; i < components.size(); i++) {
+            if (components[i].getName() == name) {
+                return true;
+            }
         }
+        return false;
+    }
+
+    bool Library::hasBus(std::string name) {
+        for (uint i = 0; i < buses.size(); i++) {
+            if (buses[i].getName() == name) {
+                return true;
+            }
+        }
+        return false;
     }
-    return false;
-}
 
 
-AddressSpace &Library::getAddressSpace(std::string addressSpace) {
-    for(uint i=0; i<addressSpaces.size(); i++) {
-        if(addressSpaces[i].getName() == addressSpace) {
-            return addressSpaces[i];
+    AddressSpace &Library::getAddressSpace(std::string addressSpace) {
+        for (uint i = 0; i < addressSpaces.size(); i++) {
+            if (addressSpaces[i].getName() == addressSpace) {
+                return addressSpaces[i];
+            }
         }
+        throw std::exception();
     }
-    throw std::exception();
-}
-Component &Library::getComponent(std::string component) {
-    for(uint i=0; i<components.size(); i++) {
-        if(components[i].getName() == component) {
-            return components[i];
-        }
-    }
-    throw std::exception();
-}
-Bus &Library::getBus(std::string bus) {
-    for(uint i=0; i<buses.size(); i++) {
-        if(buses[i].getName() == bus) {
-            return buses[i];
-        }
-    }
-    throw std::exception();
 
-}
-
-bool Library::hasConnection(ConnectionComponent component, std::string bus) {
-    return getConnection(component, bus).has_value();
-}
-std::optional<Connection> Library::getConnection(ConnectionComponent component, std::string bus) {
-    for(uint i=0; i<connections.size(); i++) {
-        if(connections[i].isConnecting(component, bus)) {
-            return connections[i];
+    Component &Library::getComponent(std::string component) {
+        for (uint i = 0; i < components.size(); i++) {
+            if (components[i].getName() == component) {
+                return components[i];
+            }
         }
+        throw std::exception();
     }
-    return nullopt;
-}
 
-bool Library::hasConnection(ConnectionComponent component, std::string bus, ConnectionComponent secondComponent) {
-    return getConnection(component, bus, secondComponent).has_value();
-}
-std::optional<Connection> Library::getConnection(ConnectionComponent component, std::string bus, ConnectionComponent secondComponent) {
-    for(uint i=0; i<connections.size(); i++) {
-        if(connections[i].isConnecting(component, bus, secondComponent)) {
-            return connections[i];
+    Bus &Library::getBus(std::string bus) {
+        for (uint i = 0; i < buses.size(); i++) {
+            if (buses[i].getName() == bus) {
+                return buses[i];
+            }
         }
-    }
-    return nullopt;
-}
+        throw std::exception();
 
-std::string Library::getMessage(std::string key) {
-    return messages[key];
-}
+    }
+
+    bool Library::hasConnection(ConnectionComponent component, std::string bus) {
+        return getConnection(component, bus).has_value();
+    }
+
+    std::optional<Connection> Library::getConnection(ConnectionComponent component, std::string bus) {
+        for (uint i = 0; i < connections.size(); i++) {
+            if (connections[i].isConnecting(component, bus)) {
+                return connections[i];
+            }
+        }
+        return nullopt;
+    }
+
+    bool Library::hasConnection(ConnectionComponent component, std::string bus, ConnectionComponent secondComponent) {
+        return getConnection(component, bus, secondComponent).has_value();
+    }
+
+    std::optional<Connection>
+    Library::getConnection(ConnectionComponent component, std::string bus, ConnectionComponent secondComponent) {
+        for (uint i = 0; i < connections.size(); i++) {
+            if (connections[i].isConnecting(component, bus, secondComponent)) {
+                return connections[i];
+            }
+        }
+        return nullopt;
+    }
+
+    std::string Library::getMessage(std::string key) {
+        return messages[key];
+    }
 
     bool Library::hasConnection(ConnectionComponent component, ConnectionComponent secondComponent) {
         return getConnection(component, secondComponent).has_value();
@@ -119,8 +134,8 @@ std::string Library::getMessage(std::string key) {
 
     std::optional<Connection>
     Library::getConnection(ConnectionComponent component, ConnectionComponent secondComponent) {
-        for(auto & connection : connections) {
-            if(connection.isConnecting(component, secondComponent)) {
+        for (auto &connection: connections) {
+            if (connection.isConnecting(component, secondComponent)) {
                 return connection;
             }
         }

comdel/domain/library.h

@@ -1,7 +1,7 @@
 #ifndef DOMAIN_LIBRARY_H
 #define DOMAIN_LIBRARY_H
 
-#include "addressspace.h"
+#include "address_space.h"
 #include "bus.h"
 #include "component.h"
 #include "connection.h"
@@ -10,61 +10,75 @@
 #include <vector>
 
 
-
 namespace domain {
 
-using namespace std;
+    using namespace std;
 
-class Library
-{
-    std::string name;
-    std::string libraryInfo;
-    std::string header;
-    std::string componentDirectory;
-    std::optional<std::string> componentHeader;
+    class Library {
+        std::string name;
+        std::string libraryInfo;
+        std::string header;
+        std::string componentDirectory;
+        std::optional<std::string> componentHeader;
 
-    std::vector<AddressSpace> addressSpaces;
-    std::vector<Component> components;
-    std::vector<Bus> buses;
-    std::vector<Connection> connections;
+        std::vector<AddressSpace> addressSpaces;
+        std::vector<Component> components;
+        std::vector<Bus> buses;
+        std::vector<Connection> connections;
 
-    std::map<std::string, std::string> messages;
+        std::map<std::string, std::string> messages;
 
-public:
-    Library(string name, string libraryInfo, string header, string componentDirectory, std::optional<string> componentHeader,
-            vector<AddressSpace> addressSpaces, vector<Component> components, vector<Bus> buses, vector<Connection> connection, map<string, string> messages);
+    public:
+        Library(string name, string libraryInfo, string header, string componentDirectory,
+                std::optional<string> componentHeader,
+                vector<AddressSpace> addressSpaces, vector<Component> components, vector<Bus> buses,
+                vector<Connection> connection, map<string, string> messages);
 
-    std::string getName();
-    std::string getLibraryInfo();
-    std::string getHeader();
-    std::string getComponentDirectory();
-    std::optional<std::string> getComponentHeader();
+        std::string getName();
 
-    std::vector<AddressSpace> getAddressSpaces();
-    std::vector<Component> getComponents();
-    std::vector<Bus> getBuses();
-    std::vector<Connection> getConnections();
+        std::string getLibraryInfo();
 
-    bool hasComponent(std::string name);
-    bool hasBus(std::string name);
+        std::string getHeader();
 
-    std::map<std::string, std::string> getMessages();
+        std::string getComponentDirectory();
 
-    AddressSpace &getAddressSpace(std::string name);
-    Component &getComponent(std::string name);
-    Bus &getBus(std::string bus);
-    std::string getMessage(std::string key);
+        std::optional<std::string> getComponentHeader();
 
-    bool hasConnection(ConnectionComponent component, std::string bus);
-    std::optional<Connection> getConnection(ConnectionComponent component, std::string bus);
+        std::vector<AddressSpace> getAddressSpaces();
 
-    bool hasConnection(ConnectionComponent component, std::string bus, ConnectionComponent secondComponent);
-    std::optional<Connection> getConnection(ConnectionComponent component, std::string bus, ConnectionComponent secondComponent);
+        std::vector<Component> getComponents();
 
-    bool hasConnection(ConnectionComponent component, ConnectionComponent secondComponent);
-    std::optional<Connection> getConnection(ConnectionComponent component, ConnectionComponent secondComponent);
+        std::vector<Bus> getBuses();
 
-};
+        std::vector<Connection> getConnections();
+
+        bool hasComponent(std::string name);
+
+        bool hasBus(std::string name);
+
+        std::map<std::string, std::string> getMessages();
+
+        AddressSpace &getAddressSpace(std::string name);
+
+        Component &getComponent(std::string name);
+
+        Bus &getBus(std::string bus);
+
+        std::string getMessage(std::string key);
+
+        bool hasConnection(ConnectionComponent component, std::string bus);
+
+        std::optional<Connection> getConnection(ConnectionComponent component, std::string bus);
+
+        bool hasConnection(ConnectionComponent component, std::string bus, ConnectionComponent secondComponent);
+
+        std::optional<Connection> getConnection(ConnectionComponent component, std::string bus, ConnectionComponent secondComponent);
+
+        bool hasConnection(ConnectionComponent component, ConnectionComponent secondComponent);
+
+        std::optional<Connection> getConnection(ConnectionComponent component, ConnectionComponent secondComponent);
+
+    };
 
 } // namespace domain
 

comdel/domain/pin.cpp

@@ -2,40 +2,45 @@
 
 namespace domain {
 
-PinConnection::PinConnection(std::string message, ConnectionType type)
-    : message(message), type(type)
-{}
+    PinConnection::PinConnection(std::string message, ConnectionType type)
+            : message(message), type(type) {}
 
-PinConnection::ConnectionType PinConnection::getType() {
-    return type;
-}
-std::string PinConnection::getMessage() {
-    return message;
-}
+    PinConnection::ConnectionType PinConnection::getType() {
+        return type;
+    }
+
+    std::string PinConnection::getMessage() {
+        return message;
+    }
 
 
-Pin::Pin(std::string name, PinType type, std::string tooltip, PinConnection connection, domain::ui::Pin pin, std::optional<std::vector<Value>> wires)
-    : name(name), type(type), tooltip(tooltip), connection(connection), displayPin(pin), wires(wires)
-{}
+    Pin::Pin(std::string name, PinType type, std::string tooltip, PinConnection connection, domain::ui::Pin pin,
+             std::optional<std::vector<Value>> wires)
+            : name(name), type(type), tooltip(tooltip), connection(connection), displayPin(pin), wires(wires) {}
 
-std::string &Pin::getName() {
-    return name;
-}
-Pin::PinType Pin::getType() {
-    return type;
-}
-std::string Pin::getTooltip() {
-    return tooltip;
-}
-ui::Pin &Pin::getDisplayPin() {
-    return displayPin;
-}
-PinConnection &Pin::getConnection() {
-    return connection;
-}
-std::optional<std::vector<Value>> &Pin::getWires() {
-    return wires;
-}
+    std::string &Pin::getName() {
+        return name;
+    }
+
+    Pin::PinType Pin::getType() {
+        return type;
+    }
+
+    std::string Pin::getTooltip() {
+        return tooltip;
+    }
+
+    ui::Pin &Pin::getDisplayPin() {
+        return displayPin;
+    }
+
+    PinConnection &Pin::getConnection() {
+        return connection;
+    }
+
+    std::optional<std::vector<Value>> &Pin::getWires() {
+        return wires;
+    }
 
 
 } // namespace domain

comdel/domain/pin.h

@@ -7,57 +7,61 @@
 #include <string>
 
 
-
 namespace domain {
 
-class PinConnection
-{
-public:
-    enum ConnectionType {
-        REQUIRED,
-        OPTIONAL
+    class PinConnection {
+    public:
+        enum ConnectionType {
+            REQUIRED,
+            OPTIONAL
+        };
+
+    private:
+        std::string message;
+        ConnectionType type;
+
+    public:
+        PinConnection(std::string message, ConnectionType type);
+
+        ConnectionType getType();
+
+        std::string getMessage();
     };
 
-private:
-    std::string message;
-    ConnectionType type;
+    class Pin {
+    public:
+        enum PinType {
+            IN_OUT,
+            IN,
+            OUT
+        };
 
-public:
-    PinConnection(std::string message, ConnectionType type);
+    private:
+        std::string name;
+        PinType type;
+        std::string tooltip;
+        PinConnection connection;
+        domain::ui::Pin displayPin;
 
-    ConnectionType getType();
-    std::string getMessage();
-};
+        std::optional<std::vector<Value>> wires;
 
-class Pin
-{
-public:
-    enum PinType {
-        IN_OUT,
-        IN,
-        OUT
+    public:
+        Pin(std::string name, PinType type, std::string tooltip, PinConnection connection, domain::ui::Pin pin,
+            std::optional<std::vector<Value>> wires);
+
+        std::string &getName();
+
+        PinType getType();
+
+        std::string getTooltip();
+
+        ui::Pin &getDisplayPin();
+
+        PinConnection &getConnection();
+
+        std::optional<std::vector<Value>> &getWires();
     };
 
-private:
-    std::string name;
-    PinType type;
-    std::string tooltip;
-    PinConnection connection;
-    domain::ui::Pin displayPin;
-
-    std::optional<std::vector<Value>> wires;
-
-public:
-    Pin(std::string name, PinType type, std::string tooltip, PinConnection connection, domain::ui::Pin pin, std::optional<std::vector<Value>> wires);
-
-    std::string &getName();
-    PinType getType();
-    std::string getTooltip();
-    ui::Pin &getDisplayPin();
-    PinConnection &getConnection();
-    std::optional<std::vector<Value>> &getWires();
-};
-
 } // namespace domain
 
 #endif // DOMAIN_PIN_H

comdel/domain/rule.cpp

@@ -1,62 +1,61 @@
 #include "rule.h"
 
+#include <utility>
+
 namespace domain {
 
-Condition::Condition(std::string function, std::vector<Value> params, bool negated)
-    : negated(negated), function(function), params(params)
-{}
+    Condition::Condition(std::string function, std::vector<Value> params, bool negated)
+            : negated(negated), function(std::move(function)), params(std::move(params)) {}
 
-bool Condition::evaluate(RuleContext &context) {
-    std::vector<Value> request;
-    for(unsigned int i=0; i<params.size(); i++) {
-        if(params[i].isType(Value::ADDRESS_SPACE_REFERENCE)) {
-            request.push_back(Value::fromAddressSpace(context.addressSpaces.at(params[i].asReference())));
-        } else if(params[i].isType(Value::ATTRIBUTE_REFERENCE)) {
-            request.push_back(context.attributes[params[i].asReference()]);
-        } else {
-            request.push_back(params[i]);
+    bool Condition::evaluate(RuleContext &context) {
+        std::vector<Value> request;
+        for (auto & param : params) {
+            if (param.isType(Value::ADDRESS_SPACE_REFERENCE)) {
+                request.push_back(Value::fromAddressSpace(context.addressSpaces.at(param.asReference())));
+            } else if (param.isType(Value::ATTRIBUTE_REFERENCE)) {
+                request.push_back(context.attributes[param.asReference()]);
+            } else {
+                request.push_back(param);
+            }
         }
+        bool result = context.function[function]->validate(request);
+        return negated ? !result : result;
     }
-    bool result = context.function[function]->validate(request);
-    return negated ? !result : result;
-}
 
 
-Action::Action(ActionType type, std::string message)
-    : type(type), message(message)
-{}
+    Action::Action(ActionType type, std::string message)
+            : type(type), message(std::move(message)) {}
 
-Action::ActionType Action::getType() {
-    return type;
-}
-std::string Action::getMessage() {
-    return message;
-}
-
-
-IfStatement::IfStatement(Condition condition, Action action)
-    : condition(condition), action(action)
-{}
-
-std::optional<Action> IfStatement::evaluate(RuleContext &context) {
-    if(condition.evaluate(context)) {
-        return action;
+    Action::ActionType Action::getType() {
+        return type;
     }
-    return std::nullopt;
-}
 
-Rule::Rule(std::vector<IfStatement> statements)
-    : statements(statements)
-{}
+    std::string Action::getMessage() {
+        return message;
+    }
 
-std::optional<Action> Rule::evaluate(RuleContext &context) {
-    for(unsigned int i=0; i<statements.size(); i++) {
-        auto response = statements[i].evaluate(context);
-        if(response) {
-            return response;
+
+    IfStatement::IfStatement(Condition condition, Action action)
+            : condition(std::move(condition)), action(std::move(action)) {}
+
+    std::optional<Action> IfStatement::evaluate(RuleContext &context) {
+        if (condition.evaluate(context)) {
+            return action;
         }
+        return std::nullopt;
+    }
+
+    Rule::Rule(std::vector<IfStatement> statements)
+            : statements(std::move(statements)) {}
+
+    std::optional<Action> Rule::evaluate(RuleContext &context) {
+        for (auto & statement : statements) {
+            auto response = statement.evaluate(context);
+            if (response) {
+                return response;
+            }
+        }
+        return std::nullopt;
     }
-    return std::nullopt;
-}
 
 } // namespace domain

comdel/domain/rule.h

@@ -1,9 +1,9 @@
 #ifndef DOMAIN_RULE_H
 #define DOMAIN_RULE_H
 
-#include "addressspace.h"
+#include "address_space.h"
 #include "value.h"
-#include "functionsignature.h"
+#include "function_signature.h"
 
 #include <map>
 #include <string>
@@ -12,58 +12,58 @@
 
 namespace domain {
 
-struct RuleContext {
-    std::map<std::string, AddressSpace> addressSpaces;
-    std::map<std::string, Value> attributes;
-    std::map<std::string, FunctionValidator*> function;
-};
-
-class Condition {
-    bool negated;
-    std::string function;
-    std::vector<Value> params;
-
-public:
-    Condition(std::string function, std::vector<Value> params, bool negated);
-
-    bool evaluate(RuleContext &context);
-};
-
-class Action {
-public:
-    enum ActionType {
-        ERROR,
-        WARNING
+    struct RuleContext {
+        std::map<std::string, AddressSpace> addressSpaces;
+        std::map<std::string, Value> attributes;
+        std::map<std::string, FunctionValidator *> function;
     };
 
-private:
-    ActionType type;
-    std::string message;
+    class Condition {
+        bool negated;
+        std::string function;
+        std::vector<Value> params;
 
-public:
-    Action(ActionType type, std::string message);
+    public:
+        Condition(std::string function, std::vector<Value> params, bool negated);
 
-    ActionType getType();
-    std::string getMessage();
-};
+        bool evaluate(RuleContext &context);
+    };
 
-class IfStatement {
-    Condition condition;
-    Action action;
-public:
-    IfStatement(Condition condition, Action action);
+    class Action {
+    public:
+        enum ActionType {
+            ERROR,
+            WARNING
+        };
 
-    std::optional<Action> evaluate(RuleContext &context);
-};
+    private:
+        ActionType type;
+        std::string message;
 
-class Rule
-{
-    std::vector<IfStatement> statements;
-public:
-    Rule(std::vector<IfStatement> statements);
+    public:
+        Action(ActionType type, std::string message);
 
-    std::optional<Action> evaluate(RuleContext &context);
-};
+        ActionType getType();
+
+        std::string getMessage();
+    };
+
+    class IfStatement {
+        Condition condition;
+        Action action;
+    public:
+        IfStatement(Condition condition, Action action);
+
+        std::optional<Action> evaluate(RuleContext &context);
+    };
+
+    class Rule {
+        std::vector<IfStatement> statements;
+    public:
+        explicit Rule(std::vector<IfStatement> statements);
+
+        std::optional<Action> evaluate(RuleContext &context);
+    };
 
 } // namespace domain
 

comdel/domain/schema.cpp

@@ -2,27 +2,41 @@
 
 namespace domain {
 
-Schema::Schema()
-{
-}
+    bool Schema::hasConnection(string &component, string &pin) {
+        return getConnection(component, pin) != nullptr;
+    }
 
-bool Schema::hasConnection(string& component, string& pin) {
-    return getConnection(component, pin) != nullptr;
-}
-
-ConnectionInstance* Schema::getConnection(string& component, string& pin) {
-    for(auto& conn: connections) {
-        if(conn->instance->name == component && conn->connection.getComponent().pin == pin) {
-            return conn.get();
-        }
-        auto dirConn = dynamic_cast<DirectConnectionInstance*>(conn.get());
-        if(dirConn != nullptr) {
-            if(dirConn->secondInstance->name == component && conn->connection.getSecondComponent()->pin == pin) {
-                return dirConn;
+    ConnectionInstance *Schema::getConnection(string &component, string &pin) {
+        for (auto &conn: connections) {
+            if (conn->instance->name == component && conn->connection.getComponent().pin == pin) {
+                return conn.get();
+            }
+            auto dirConn = dynamic_cast<DirectConnectionInstance *>(conn.get());
+            if (dirConn != nullptr) {
+                if (dirConn->secondInstance->name == component && conn->connection.getSecondComponent()->pin == pin) {
+                    return dirConn;
+                }
             }
         }
+        return nullptr;
+    }
+
+    BusInstance *Schema::getBusInstance(string &name) {
+        for (auto &instance: busInstances) {
+            if (instance->name == name) {
+                return instance.get();
+            }
+        }
+        return nullptr;
+    }
+
+    ComponentInstance *Schema::getComponentInstance(string &name) {
+        for (auto &instance: componentInstances) {
+            if (instance->name == name) {
+                return instance.get();
+            }
+        }
+        return nullptr;
     }
-    return nullptr;
-}
 
 } // namespace domain

comdel/domain/schema.h

@@ -1,45 +1,27 @@
 #ifndef DOMAIN_SCHEMA_H
 #define DOMAIN_SCHEMA_H
 
-#include "connectioninstance.h"
+#include "connection_instance.h"
 #include "instance.h"
-#include "wireinstance.h"
 
 #include <vector>
 
 namespace domain {
 
-class Schema {
-public:
-    Schema();
+    class Schema {
+    public:
+        Schema() = default;
 
-    std::vector<shared_ptr<BusInstance>> busInstances;
-    std::vector<shared_ptr<ComponentInstance>> componentInstances;
+        std::vector<shared_ptr<BusInstance>> busInstances;
+        std::vector<shared_ptr<ComponentInstance>> componentInstances;
 
-    std::vector<shared_ptr<ConnectionInstance>> connections;
+        std::vector<shared_ptr<ConnectionInstance>> connections;
 
-    BusInstance *getBusInstance(std::string &name) {
-        for (auto &instance: busInstances) {
-            if (instance->name == name) {
-                return instance.get();
-            }
-        }
-        return nullptr;
-    }
-
-    ComponentInstance *getComponentInstance(std::string &name) {
-        for (auto &instance: componentInstances) {
-            if (instance->name == name) {
-                return instance.get();
-            }
-        }
-        return nullptr;
-    }
-
-    bool hasConnection(string &component, string &pin);
-
-    ConnectionInstance *getConnection(string &component, string &pin);
-};
+        BusInstance *getBusInstance(std::string &name);
+        ComponentInstance *getComponentInstance(std::string &name);
+        bool hasConnection(string &component, string &pin);
+        ConnectionInstance *getConnection(string &component, string &pin);
+    };
 
 } // namespace domain
 

comdel/domain/schema_creator.h

@@ -0,0 +1,93 @@
+#ifndef DOMAIN_COMDEL_GENERATOR_H
+#define DOMAIN_COMDEL_GENERATOR_H
+
+#include "library.h"
+#include "schema.h"
+
+#include <set>
+#include <utility>
+
+#include <comdel/parser/ast_nodes.h>
+#include <comdel/parser/parse_context.h>
+#include <comdel/parser/presult.h>
+
+namespace domain {
+
+    struct ComdelContext {
+        std::vector<Attribute> attributes;
+        std::vector<std::string> wires;
+        std::string name;
+        bool inComponent;
+        bool inConnection;
+        bool inSingleAutomaticConnection;
+        bool inBus;
+
+        ComdelContext(std::string name, bool inComponent, bool inConnection, bool inSingleAutomaticConnection, bool inBus);
+
+        bool doesAttributeExists(std::string name, Value::ValueType type);
+        bool doesWireExists(std::string name);
+
+    };
+
+    class SchemaCreator {
+        std::vector<ComdelContext> context;
+
+        std::string name;
+        std::string libraryInfo;
+        std::string header;
+        std::string componentDirectory;
+        std::optional<std::string> componentHeader = nullopt;
+        std::vector<AddressSpace> addressSpaces;
+        std::vector<Component> components;
+        std::vector<Bus> buses;
+        std::vector<Connection> connections;
+        std::map<std::string, std::string> messages;
+
+
+        std::vector<SourceError> errors;
+        std::vector<FunctionValidator *> validators;
+
+
+        std::optional<AddressSpace> loadAddressSpace(AddressSpaceNode node);
+        std::optional<Component> loadComponent(ComponentNode node);
+        std::optional<Attribute> loadAttribute(AttributeNode node);
+        std::optional<Rule> loadRule(RuleNode node);
+        std::optional<Condition> loadCondition(ConditionNode node);
+        std::optional<Popup> loadPopup(PopupNode node, std::string name, Value::ValueType type);
+        std::optional<Display> loadDisplay(DisplayNode node);
+        std::optional<Wire> loadWire(WireNode node);
+        std::optional<Pin> loadPin(PinNode pins);
+
+        PinConnection loadPinConnection(PinConnectionNode node);
+
+        std::optional<Connection> loadConnection(ConnectionNode node);
+        std::optional<Bus> loadBus(BusNode node);
+
+        std::shared_ptr<ComponentInstance> loadComponentInstance(InstanceNode instance, Library &library);
+        std::shared_ptr<BusInstance> loadBusInstance(InstanceNode instance, Library &library);
+
+        std::optional<Bus> getBus(std::string name);
+        std::optional<Pin> getComponentPin(std::string name, std::string pin);
+        bool hasAddressSpace(std::string name);
+
+        void push(ComdelContext context);
+        void pushAdditional(std::string name);
+        ComdelContext &current();
+        void pop();
+
+        std::optional<Attribute> createMemoryAttribute();
+        vector<Enumeration> createWireEnumeration(vector<Value> enumeration);
+        std::optional<Popup> createMemoryPopup();
+
+    public:
+        explicit SchemaCreator(std::vector<FunctionValidator *> validators);
+
+        std::vector<SourceError> getErrors();
+
+        std::optional<Library> loadLibrary(LibraryNode node);
+        Schema *loadSchema(SchemaNode node, Library &library);
+    };
+
+} // namespace domain
+
+#endif // DOMAIN_COMDEL_GENERATOR_H

comdel/domain/schemacreator.h

@@ -1,153 +0,0 @@
-#ifndef DOMAIN_COMDEL_GENERATOR_H
-#define DOMAIN_COMDEL_GENERATOR_H
-
-#include "library.h"
-#include "schema.h"
-
-#include <set>
-
-#include <comdel/parser/astnode.h>
-#include <comdel/parser/parsecontext.h>
-#include <comdel/parser/presult.h>
-
-namespace domain {
-
-struct ComdelContext {
-    std::vector<Attribute> attributes;
-    std::vector<std::string> wires;
-    std::string name;
-    bool inComponent;
-    bool inConnection;
-    bool inSingleAutomaticConnection;
-    bool inBus;
-
-    ComdelContext(std::string name, bool inComponent, bool inConnection, bool inSingleAutomaticConnection, bool inBus)
-        : name(name), inComponent(inComponent), inConnection(inConnection), inSingleAutomaticConnection(inSingleAutomaticConnection), inBus(inBus)
-    {}
-
-    bool doesAttributeExists(std::string name, Value::ValueType type) {
-        for(auto &attribute: attributes) {
-            if(attribute.getDefault().getType() == type && attribute.getName() == name) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    bool doesWireExists(std::string name) {
-        for(auto &w: wires) {
-            if(w == name) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-};
-
-class SchemaCreator
-{
-    std::vector<ComdelContext> context;
-
-    std::string name;
-    std::string libraryInfo;
-    std::string header;
-    std::string componentDirectory;
-    std::optional<std::string> componentHeader = nullopt;
-    std::vector<AddressSpace> addressSpaces;
-    std::vector<Component> components;
-    std::vector<Bus> buses;
-    std::vector<Connection> connections;
-    std::map<std::string, std::string> messages;
-
-
-    std::vector<SourceError> errors;
-    std::vector<FunctionValidator*> validators;
-
-    std::optional<AddressSpace> loadAddressSpace(AddressSpaceNode node);
-    std::optional<Component> loadComponent(ComponentNode node);
-    std::optional<Attribute> loadAttribute(AttributeNode node);
-    std::optional<Rule> loadRule(RuleNode node);
-    std::optional<Condition> loadCondition(ConditionNode node);
-    std::optional<Popup> loadPopup(PopupNode node, std::string name, Value::ValueType type);
-    std::optional<Display> loadDisplay(DisplayNode node);
-    std::optional<Wire> loadWire(WireNode node);
-    std::optional<Pin> loadPin(PinNode pins);
-    PinConnection loadPinConnection(PinConnectionNode node);
-    std::optional<Connection> loadConnection(ConnectionNode node);
-    std::optional<Bus> loadBus(BusNode node);
-
-    std::shared_ptr<ComponentInstance> loadComponentInstance(InstanceNode instance, Library &library);
-    std::shared_ptr<BusInstance> loadBusInstance(InstanceNode instance, Library &library);
-
-    std::optional<Attribute> createMemoryAttribute();
-
-    std::optional<Bus> getBus(std::string name) {
-        for(auto &bus: buses) {
-            if(bus.getName() == name) {
-                return bus;
-            }
-        }
-        return std::nullopt;
-    }
-
-    std::optional<Pin> getComponentPin(std::string name, std::string pin) {
-        for(auto &c: components) {
-            if(c.getName() == name) {
-                for(auto &p: c.getPins()) {
-                    if(p.getName() == pin) {
-                        return p;
-                    }
-                }
-            }
-        }
-        return nullopt;
-    }
-
-    bool hasAddressSpace(std::string name) {
-        for(auto &as: addressSpaces) {
-            if(as.getName() == name) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    void push(ComdelContext context) {
-        this->context.push_back(context);
-    }
-    void pushAdditional(std::string name) {
-        if(!this->context.empty()) {
-            this->context.push_back(current());
-            current().name = name;
-        } else {
-            ComdelContext con(name, false, false, false, false);
-            push(con);
-        }
-    }
-    ComdelContext &current() {
-        return this->context[this->context.size() - 1];
-    }
-    void pop() {
-        this->context.pop_back();
-    }
-
-public:
-    SchemaCreator(std::vector<FunctionValidator*> validators);
-
-    std::vector<SourceError> getErrors() {
-        return errors;
-    }
-
-    std::optional<Library> loadLibrary(LibraryNode node);
-
-    Schema* loadSchema(SchemaNode node, Library &library);
-
-    vector <Enumeration> createWireEnumeration(vector<Value> vector1);
-
-    std::optional<Popup> createMemoryPopup();
-};
-
-} // namespace domain
-
-#endif // DOMAIN_COMDEL_GENERATOR_H

comdel/domain/value.cpp

@@ -4,173 +4,160 @@
 
 namespace domain {
 
-std::string Value::string() {
-    switch (type) {
-        case INT:
-            return std::to_string(intValue);
-        case BOOL:
-            return boolValue ? "true" : "false";
-        case STRING:
+    std::string Value::string() {
+        switch (type) {
+            case INT:
+                return std::to_string(intValue);
+            case BOOL:
+                return boolValue ? "true" : "false";
+            case STRING:
+                return stringValue;
+            case NIL:
+                return "null";
+            case UNDEFINED:
+                return "undefined";
+            case ADDRESS_SPACE:
+                return "AddressSpace::" + addressSpace->getName();
+            case WIRE_REFERENCE:
+                return "Wire::" + reference;
+            case ADDRESS_SPACE_REFERENCE:
+                return "AddressSpace::" + reference;
+            case ATTRIBUTE_REFERENCE:
+                return "Attribute::" + reference;
+            case MEMORY_REFERENCE:
+                if (memoryReference.has_value()) {
+                    return "Memory::" + *memoryReference;
+                } else {
+                    return "Memory::null";
+                }
+            default:
+                return "unknown";
+        }
+    }
+
+
+    Value::ValueType Value::getType() {
+        return type;
+    }
+
+    bool Value::isType(Value::ValueType _type) {
+        return type == _type;
+    }
+
+    long long Value::asInt() {
+        if (isType(Value::INT)) {
+            return intValue;
+        }
+        throw std::exception();
+    }
+
+    std::string Value::asString() {
+        if (isType(Value::STRING)) {
             return stringValue;
-        case NIL:
-            return "null";
-        case UNDEFINED:
-            return "undefined";
-        case ADDRESS_SPACE:
-            return "AddressSpace::" + addressSpace->getName();
-        case WIRE_REFERENCE:
-            return "Wire::" + reference;
-        case ADDRESS_SPACE_REFERENCE:
-            return "AddressSpace::" + reference;
-        case ATTRIBUTE_REFERENCE:
-            return "Attribute::" + reference;
-        default:
-            return "unknown";
+        }
+        throw std::exception();
     }
-}
 
+    bool Value::asBool() {
+        if (isType(Value::BOOL)) {
+            return boolValue;
+        }
+        throw std::exception();
+    }
 
-Value::ValueType Value::getType() {
-    return type;
-}
-bool Value::isType(Value::ValueType type) {
-    return this->type == type;
-}
+    AddressSpace Value::asAddressSpace() {
+        if (isType(Value::ADDRESS_SPACE)) {
+            return *addressSpace;
+        }
+        throw std::exception();
+    }
 
-long long Value::asInt() {
-    if(isType(Value::INT)) {
-        return intValue;
+    std::string Value::asReference() {
+        if (isType(Value::WIRE_REFERENCE) || isType(Value::ADDRESS_SPACE_REFERENCE) ||
+            isType(Value::ATTRIBUTE_REFERENCE) || isType(Value::UNDEFINED)) {
+            return reference;
+        }
+        throw std::exception();
     }
-    throw std::exception();
-}
-std::string Value::asString() {
-    if(isType(Value::STRING)) {
-        return stringValue;
-    }
-    throw std::exception();
-}
-bool Value::asBool() {
-    if(isType(Value::BOOL)) {
-        return boolValue;
-    }
-    throw std::exception();
-}
-AddressSpace Value::asAddressSpace() {
-    if(isType(Value::ADDRESS_SPACE)) {
-        return *addressSpace;
-    }
-    throw std::exception();
-}
-std::string Value::asReference() {
-    if(isType(Value::WIRE_REFERENCE) || isType(Value::ADDRESS_SPACE_REFERENCE) || isType(Value::ATTRIBUTE_REFERENCE) || isType(Value::UNDEFINED)) {
-        return reference;
-    }
-    throw std::exception();
-}
 
-
-std::optional<std::string> Value::asMemoryReference() {
-    return memoryReference;
-}
+    std::optional<std::string> Value::asMemoryReference() {
+        return memoryReference;
+    }
 
     domain::ComponentInstance *Value::asMemory() {
         return memory;
     }
 
 
-void Value::setInt(long long value) {
-    if(isType(Value::INT)) {
-        this->intValue = value;
+    void Value::setInt(long long value) {
+        if (isType(Value::INT)) {
+            this->intValue = value;
+        }
+        throw std::exception();
     }
-    throw std::exception();
-}
-void Value::setString(std::string value) {
-    if(isType(Value::STRING)) {
-        this->stringValue = value;
+
+    void Value::setString(std::string value) {
+        if (isType(Value::STRING)) {
+            this->stringValue = value;
+        }
+        throw std::exception();
     }
-    throw std::exception();
-}
-void Value::setBool(bool value) {
-    if(isType(Value::BOOL)) {
-        this->boolValue = value;
+
+    void Value::setBool(bool value) {
+        if (isType(Value::BOOL)) {
+            this->boolValue = value;
+        }
+        throw std::exception();
     }
-    throw std::exception();
-}
-void Value::setReference(std::string value) {
-    if(isType(Value::WIRE_REFERENCE)) {
-        this->reference = value;
+
+    void Value::setReference(std::string value) {
+        if (isType(Value::WIRE_REFERENCE)) {
+            this->reference = value;
+        }
+        throw std::exception();
     }
-    throw std::exception();
-}
 
 
-Value Value::fromInt(long long value) {
-    Value val;
-    val.type = Value::INT;
-    val.intValue = value;
-    return val;
-}
-Value Value::fromString(std::string value) {
-    Value val;
-    val.type = Value::STRING;
-    val.stringValue = value;
-    return val;
-}
-Value Value::fromBool(bool value) {
-    Value val;
-    val.type = Value::BOOL;
-    val.boolValue = value;
-    return val;
-}
-Value Value::fromAddressSpace(AddressSpace addressSpace) {
-    Value val;
-    val.type = Value::ADDRESS_SPACE;
-    val.addressSpace = addressSpace;
-    return val;
-}
-Value Value::fromReference(std::string value, Value::ValueType type) {
-    Value val;
-    val.type = type;
-    val.reference = value;
-    return val;
-}
+    Value Value::fromInt(long long value) {
+        Value val;
+        val.type = Value::INT;
+        val.intValue = value;
+        return val;
+    }
 
-Value Value::ofType(Value::ValueType type) {
-    Value val;
-    val.type = type;
-    return val;
-}
+    Value Value::fromString(std::string value) {
+        Value val;
+        val.type = Value::STRING;
+        val.stringValue = value;
+        return val;
+    }
 
-Value Value::fromNull() {
-    Value val;
-    val.type = Value::NIL;
-    return val;
-}
+    Value Value::fromBool(bool value) {
+        Value val;
+        val.type = Value::BOOL;
+        val.boolValue = value;
+        return val;
+    }
 
-std::string Value::stringify() {
-    switch (type) {
-        case INT:
-            return std::to_string(intValue);
-        case BOOL:
-            return boolValue ? "true" : "false";
-        case STRING:
-            return "\"" + stringValue + "\"";
-        case NIL:
-            return "null";
-        case WIRE_REFERENCE:
-        case ADDRESS_SPACE_REFERENCE:
-        case ATTRIBUTE_REFERENCE:
-            return reference;
-        case MEMORY_REFERENCE:
-            if(memoryReference.has_value()) {
-                return memoryReference.value();
-            } else {
-                return "null";
-            }
-        default:
-            throw std::exception();
+    Value Value::fromAddressSpace(AddressSpace addressSpace) {
+        Value val;
+        val.type = Value::ADDRESS_SPACE;
+        val.addressSpace = addressSpace;
+        return val;
+    }
+
+    Value Value::fromReference(std::string value, Value::ValueType type) {
+        Value val;
+        val.type = type;
+        val.reference = value;
+        return val;
+    }
+
+    Value Value::fromNull() {
+        Value val;
+        val.type = Value::NIL;
+        return val;
     }
-}
 
     Value Value::fromMemoryReference(std::optional<std::string> value) {
         Value val;
@@ -179,10 +166,34 @@ std::string Value::stringify() {
         return val;
     }
 
-    Value Value::fromMemory(domain::ComponentInstance *memory) {
+    std::string Value::stringify() {
+        switch (type) {
+            case INT:
+                return std::to_string(intValue);
+            case BOOL:
+                return boolValue ? "true" : "false";
+            case STRING:
+                return "\"" + stringValue + "\"";
+            case NIL:
+                return "null";
+            case WIRE_REFERENCE:
+            case ADDRESS_SPACE_REFERENCE:
+            case ATTRIBUTE_REFERENCE:
+                return reference;
+            case MEMORY_REFERENCE:
+                if (memoryReference.has_value()) {
+                    return memoryReference.value();
+                } else {
+                    return "null";
+                }
+            default:
+                throw std::exception();
+        }
+    }
+
+    Value Value::ofType(Value::ValueType type) {
         Value val;
-        val.type = MEMORY;
-        val.memory = memory;
+        val.type = type;
         return val;
     }
 

comdel/domain/value.h

@@ -1,7 +1,7 @@
 #ifndef DOMAIN_VALUE_H
 #define DOMAIN_VALUE_H
 
-#include "addressspace.h"
+#include "address_space.h"
 
 #include <string>
 #include <optional>
@@ -11,96 +11,111 @@ namespace domain {
 
     class ComponentInstance;
 
-class Value
-{
-public:
-    enum ValueType {
-        INT,
-        STRING,
-        BOOL,
-        ADDRESS_SPACE,
-        ADDRESS_SPACE_REFERENCE,
-        ATTRIBUTE_REFERENCE,
-        MEMORY_REFERENCE,
-        MEMORY,
-        WIRE_REFERENCE,
-        NIL,
-        UNDEFINED,
-    };
+    class Value {
+    public:
+        enum ValueType {
+            INT,
+            STRING,
+            BOOL,
+            ADDRESS_SPACE,
+            ADDRESS_SPACE_REFERENCE,
+            ATTRIBUTE_REFERENCE,
+            MEMORY_REFERENCE,
+            MEMORY,
+            WIRE_REFERENCE,
+            NIL,
+            UNDEFINED,
+        };
 
-private:
-    long long intValue = 0;
-    std::string stringValue;
-    bool boolValue = false;
-    std::optional<AddressSpace> addressSpace = std::nullopt;
-    std::string reference;
-    domain::ComponentInstance *memory = nullptr;
+    private:
+        long long intValue = 0;
+        std::string stringValue;
+        bool boolValue = false;
+        std::optional<AddressSpace> addressSpace = std::nullopt;
+        std::string reference;
+        domain::ComponentInstance *memory = nullptr;
 
-    std::optional<std::string> memoryReference = std::nullopt;
+        std::optional<std::string> memoryReference = std::nullopt;
 
-    ValueType type = UNDEFINED;
+        ValueType type = UNDEFINED;
 
-public:
+    public:
 
-    Value() {}
+        Value() = default;
 
-    bool equals(Value value) {
-        if(value.getType() == type) {
-            switch (type) {
-                case INT:
-                    return value.asInt() == intValue;
-                case STRING:
-                    return value.asString() == stringValue;
-                case NIL:
-                case UNDEFINED:
-                    return true;
-                case WIRE_REFERENCE:
-                case ATTRIBUTE_REFERENCE:
-                case ADDRESS_SPACE_REFERENCE:
-                    return value.asReference() == reference;
-                case MEMORY_REFERENCE:
-                    return value.asMemoryReference() == memoryReference;
-                case MEMORY:
-                    return value.asMemory() == memory;
-                case BOOL:
-                    return value.asBool() == boolValue;
-                default:
-                    return false;
+        bool equals(Value value) {
+            if (value.getType() == type) {
+                switch (type) {
+                    case INT:
+                        return value.asInt() == intValue;
+                    case STRING:
+                        return value.asString() == stringValue;
+                    case NIL:
+                    case UNDEFINED:
+                        return true;
+                    case WIRE_REFERENCE:
+                    case ATTRIBUTE_REFERENCE:
+                    case ADDRESS_SPACE_REFERENCE:
+                        return value.asReference() == reference;
+                    case MEMORY_REFERENCE:
+                        return value.asMemoryReference() == memoryReference;
+                    case MEMORY:
+                        return value.asMemory() == memory;
+                    case BOOL:
+                        return value.asBool() == boolValue;
+                    default:
+                        return false;
+                }
             }
+            return false;
         }
-        return false;
-    }
 
-    std::string string();
+        std::string string();
 
-    ValueType getType();
-    bool isType(ValueType type);
+        ValueType getType();
 
-    long long asInt();
-    std::string asString();
-    bool asBool();
-    std::string asReference();
-    std::optional<std::string> asMemoryReference();
-    domain::ComponentInstance* asMemory();
-    AddressSpace asAddressSpace();
+        bool isType(ValueType type);
 
-    void setInt(long long intValue);
-    void setString(std::string value);
-    void setBool(bool value);
-    void setReference(std::string value);
+        long long asInt();
 
-    std::string stringify();
+        std::string asString();
 
-    static Value fromInt(long long value);
-    static Value fromString(std::string value);
-    static Value fromBool(bool value);
-    static Value fromNull();
-    static Value fromAddressSpace(AddressSpace addressSpace);
-    static Value fromReference(std::string value, ValueType type);
-    static Value ofType(ValueType type);
-    static Value fromMemoryReference(std::optional<std::string> memoryReference);
-    static Value fromMemory(domain::ComponentInstance *memory);
-};
+        bool asBool();
+
+        std::string asReference();
+
+        std::optional<std::string> asMemoryReference();
+
+        domain::ComponentInstance *asMemory();
+
+        AddressSpace asAddressSpace();
+
+        void setInt(long long intValue);
+
+        void setString(std::string value);
+
+        void setBool(bool value);
+
+        void setReference(std::string value);
+
+        std::string stringify();
+
+        static Value fromInt(long long value);
+
+        static Value fromString(std::string value);
+
+        static Value fromBool(bool value);
+
+        static Value fromNull();
+
+        static Value fromAddressSpace(AddressSpace addressSpace);
+
+        static Value fromReference(std::string value, ValueType type);
+
+        static Value fromMemoryReference(std::optional<std::string> memoryReference);
+
+        static Value ofType(ValueType type);
+    };
 
 } // namespace domain
 

comdel/domain/wireinstance.cpp

@@ -1,10 +0,0 @@
-#include "wireinstance.h"
-
-namespace domain {
-
-WireInstance::WireInstance(std::string name, Display display, std::pair<int, int> position)
-    : name(name), display(display), position(position)
-{}
-
-
-} // namespace domain

comdel/domain/wireinstance.h

@@ -1,24 +0,0 @@
-#ifndef DOMAIN_WIRE_INSTANCE_H
-#define DOMAIN_WIRE_INSTANCE_H
-
-#include "display.h"
-
-#include <string>
-
-
-
-namespace domain {
-
-class WireInstance
-{
-public:
-    std::string name;
-    Display display;
-    std::pair<int, int> position;
-
-    WireInstance(std::string name, Display display, std::pair<int, int> position);
-};
-
-} // namespace domain
-
-#endif // DOMAIN_WIREINSTANCE_H