@startuml

skinparam linetype ortho

class Node <<Template>> { /' (also ConcreteObserver) '/
	+Node()
	#Node(const char* type)
	+~Node()
	#output : Net*
	+{abstract} clone() : Node* {query}
	#label : string
	#inputs : vector<Net*>
	+addInput(Net*) : void
	+{abstract} compare() : void
	+setOutput(Net*) : void
	+update() : void

}
class Net { /' (also ConcreteSubject) '/
	+Net()
	+~Net()
	-level : SignalLevel
	+getLevel() : int
	+setLevel(SignalLevel) : void
}

class Subject {
	+size() : int
	-observers : std::vector<Observer*>
	+attach(Observer* obs) : void
	+detach(Observer*) : void
	+notify() : void
}
interface Observer {
	+update() : void
}

class GateAnd {
	-GateAnd(const char* type)
	+GateAnd(const GateAnd* prototype)
	+~GateAnd()
	+clone() : GateAnd* {query}
	-{static} type : constexpr static const char*
	-{static} instance : static GateAnd
	+compare() : void
}
class GateNand
class GateNor
class GateNot
class GateOr
class GateXor
class NodeOutput
class NodeInput

enum SignalLevel {
  LOW
	HIGH
	UNDEFINED
}
Net -- SignalLevel
Node -- SignalLevel

Node <|-[dashed]-- GateAnd
Node <|-[dashed]-- GateNand
Node <|-[dashed]-- GateNor
Node <|-[dashed]-- GateNot
Node <|-[dashed]-- GateOr
Node <|-[dashed]-- GateXor
Node <|-[dashed]-- NodeOutput
Node <|-[dashed]-- NodeInput

class NodeInputLow
class NodeInputHigh
NodeInput <|-- NodeInputLow
NodeInput <|-- NodeInputHigh

Subject <|-- Net
Observer <|-[dashed]- Node
Node -> "owner" Net
Observer "*" - Subject

class ParserException {
	+ParserException(const char* fmt, ...)
	+~ParserException()
	-error : char*
	+what() : char*
}

class Parser {
	+Parser()
	+~Parser()
	-circuit : Circuit*
	-operator<<(Parser& parser, istream s) : istream&
	-operator>>(istream s, Parser& parser) : istream&
	+{static} filter(char* input) : size_t
	+parse(string input) : void
	+parse(istream input) : void
	+set_circuit(Circuit& circuit) : void
}
ParserException - Parser

class NodeFactory {
	+NodeFactory()
	+~NodeFactory()
	+{static} create(string type) : Node*
	-{static} find_type(string type) : Node*
	-{static} get_map() : NodeFactoryMap&
	+{static} has_type(const char* type) : bool
	+{static} has_type(string type) : bool
	-{static} normalize_type(string type) : string
	-{static} assign(const char* type, const Node* node) : void
}

class Circuit {
	+Circuit()
	+~Circuit()
	-find_node(string label) : Node*
	-nodes : std::map<string, Node*>
	-nets : vector<Net*>
	+create(string label, vector<string> nodes) : void
	+new_net(string src, vector<string> dests) : void
	+new_node(string label, string type) : void
}

Circuit ---> Net
Circuit ---> Node

Parser -[dashed]> Circuit

NodeFactory -[dashed]> Node
NodeFactory <-[dashed]- Node


@enduml