fabric

type AccessType interface {
	// Class() string                             // the "class" of action (e.g. "read")
	ID() int                                   // integer id assigned to Access Type
	Priority() int                             // priorities are not a necessity but can be helpful for ordering algorithms for posets
	Commit(DGNode) error                       // takes a DGNode to signal for ...
	Rollback(RestoreNodes, RestoreEdges) error // takes a list of all CDS nodes and edges that have been operated on

}

type BasicSignalHandler func(<-chan NodeSignal, sync.WaitGroup)

type Branch struct {
	Nodes *NodeList
	Edges *EdgeList
}

type CDS interface {
	GenNodeID() int
	GenEdgeID() int
	ListNodes() NodeList // a simple `return MyCDS.Nodes` will suffice here; once a NodeList has been created
	ListEdges() EdgeList // a simple `return MyCDS.Edges` will suffice here; once an EdgesList has been created
}

type DGNode interface {
	ID() int           // must be unique from all other DGNodes in our graph
	GetType() NodeType // specifies whether node is UI, VUI, etc.
	GetPriority() int  // not necessary, but can be useful
	ListProcedures() ProcedureList
	UpdateSignaling(SignalingMap, SignalsMap) // makes it possible to update the SignalingMap and SignalsMap for a DGNode
	ListSignalers() SignalingMap
	ListSignals() SignalsMap
	Signal(NodeSignal) // used to send the same signal to all dependents in signalers list
}

type Disjoint struct {
	Nodes *NodeList
	Edges *EdgeList
}

type Edge interface {
	ID() int // returns edge id
	GetSource() Node
	GetDestination() Node
	Immutable() bool
}

type EdgeList []Edge

type EmptyUI struct {
	AccessProcedures *ProcedureList
	Signalers        *SignalingMap
	Signals          *SignalsMap
	CDS              Section
}

type Graph struct {
	DS  CDS
	Top map[DGNode][]DGNode
	VDG []*VDG
}

type Node interface {
	ID() int // returns node id
	Immutable() bool
}

type NodeList []Node

type NodeSignal struct {
	AccessType int // should be equivalent to the ID() method return value for the Access Type
	Value      Signal
	Space      UI
}

type NodeType int

type Partition struct {
	Nodes *NodeList
	Edges *EdgeList
}

type Poset interface {
	// Graph should return a pointer to the graph that our POSET object is "wrapping"
	Graph() *Graph
	// InitGraph should take a list of nodes and order them according to the Order() method and return a new Graph
	InitGraph([]DGNode) *Graph
	// Order should be a method that determines what dependents and what
	// dependencies to assign a node in the wrapped Graph i.e. it determines
	// what edges to make for the node in the Graph.
	// Order returns the location of the DGnode inside the Graph
	Order(DGNode) error
}

type ProcedureList []AccessType

type RestoreEdges []Edge

type RestoreNodes []Node

type Root struct {
	AccessProcedures *ProcedureList
	CDS              Section
	Isroot           bool
	IsLeaf           bool
	Signalers        *SignalingMap
	Signals          *SignalsMap
	Executing        bool
	Type             NodeType
}

type Section interface {
	ListNodes() *NodeList
	ListEdges() *EdgeList
	// NOTE: UpdateNodes and UpdateEdges can be used to add or remove nodes
	// and edges from the Sections list and provide the section with a new list.
	UpdateNodeList(*NodeList)
	UpdateEdgeList(*EdgeList)
}

type Signal int

type SignalingMap map[int]chan NodeSignal

type SignalsMap map[int]<-chan NodeSignal

type Subgraph struct {
	Nodes *NodeList
	Edges *EdgeList
}

type Subset struct {
	Nodes *NodeList
	Edges *EdgeList
}

type Temporal interface {
	DGNode
	GetRoots() []UI
	IsVirtual() bool
}

type UI interface {
	DGNode
	GetSection() Section
	IsUnique() bool  // specifies whether a UI is *strictly* unique or not (a UI will always have totality-uniqueness)
	IsVirtual() bool // specifies whether a UI is virtual or not
}

type VDG struct {
	Global *Graph // a reference to the real global graph of the system
	Root   Virtual
	Top    map[Virtual][]Virtual
	Space  []int // the set of all (V)UI ids that at least one node in the VDG has access too
}

type VPoset interface {
	// VDG should return a pointer to the VDG that our VPOSET object is "wrapping"
	VDG() *VDG
	// InitGraph should take a list of nodes and order them according to the Order() method and return a new VDG
	InitGraph([]Virtual) *VDG
	// Order should be a method that determines what dependents and what
	// dependencies to assign a node in the wrapped VDG i.e. it determines
	// what edges to make for the node in the VDG.
	// Order returns the location of the Virtual node inside the VDG
	Order(Virtual) error
}

type Virtual interface {
	DGNode
	Start()        // tells the node to begin execution (usually by flipping a 'Started' boolean -- can also signal to dependents that it has started)
	Started() bool // specifies whether a node has started execution or not
	IsRoot() bool  // specifies whether VDG node is root node or not
	Subspace() UI  // the (V)UI that the Virtual node is associated to
}