graph

type DGraph struct {
	Nodes  []*Node
	Edges  EdgeList
	Layers []*Layer
}

type Edge struct {
	// contains filtered or unexported fields
}

type EdgeIntMap = hashmap[*Edge, int]

type EdgeList []*Edge

type EdgeSet = hashmap[*Edge, bool]

type EdgeSlice [][]string

type EdgeType uint8

type Layer struct {
	Nodes []*Node
	Index int
	Size
}

type Node struct {
	ID        string
	In, Out   EdgeList
	Layer     int
	LayerPos  int
	IsVirtual bool

	// Size stores the dimensions of the node and its computed (x,y) coordinates.
	// The point (x,y) is the top-left corner of the node, and (0,0) is the top-left corner of the drawing plane.
	Size
	// contains filtered or unexported fields
}

type NodeFloatMap = hashmap[*Node, float64]

type NodeIntMap = hashmap[*Node, int]

type NodeList []*Node

type NodeMap = hashmap[*Node, *Node]

type NodeSet = hashmap[*Node, bool]

type OptionNsBalance uint8

type Params struct {

	// Sets the same width and height to all non-virtual nodes
	NodeFixedSizeFunc func(n *Node)

	// Sets a width and height to individual non-virtual nodes
	NodeSizeFunc func(n *Node)

	// Controls whether the next maximum outflow node in the greedy cycle breaker is picked at random.
	// When this option is true, the greedy cycle breaker behaves non-deterministically.
	GreedyCycleBreakerRandomNodeChoice bool

	// Factor used in to determine the maximum number of iterations.
	NetworkSimplexThoroughness uint
	// If positive, factor by which thoroughness is multiplied to determine the maximum number of iterations.
	// Otherwise, ignored.
	NetworkSimplexMaxIterFactor int
	// Controls which balancing strategy to use in the network simplex layering by moving nodes to less crowded layers.
	NetworkSimplexBalance OptionNsBalance

	// Size of virtual nodes (NxN). Defaults to zero, i.e. virtual nodes are treated as points.
	VirtualNodeFixedSize float64

	// Maximum number of iterations of the WMedian orderer.
	WMedianMaxIter uint

	// Spacing between layers (above and below).
	LayerSpacing float64
	// Spacing between nodes (left and right).
	NodeSpacing float64
	// Weight factor for edges in the network simplex positioner.
	NetworkSimplexAuxiliaryGraphWeightFactor int
	// Allows choosing one of the four B&K layouts. The accepted values are: 0: bottom-right, 1: bottom-left, 2: top-right, 3: top-left.
	// The directions refer to the direction in which the algorithm sweeps layers and nodes. Different directions
	// result in different aligmnent priorities, and therefore in different positioning.
	// In case the inequality 0 <= v < 4 doesn't hold, the default balanced layout is used instead.
	BrandesKoepfLayout int
}

type Size struct {
	X, Y, W, H float64
}

type Source interface {
	Populate(*DGraph)
}