package networksimplex

Import Path
	github.com/d2lang/elk-go/internal/common/networksimplex (on go.dev)

Dependency Relation
	imports 2 packages, and imported by 3 packages

Involved Source Files

	    adapter.go
	  d n_graph.go
		Package networksimplex implements ELK's deterministic network-simplex
		layering primitive. The implementation is a direct port of ELK v0.8.1's
		org.eclipse.elk.alg.common.networksimplex package.

	    network_simplex.go
Package-Level Type Names (total 8)

	/* sort by: alphabet | popularity */
	 type Adapter[N, E] (struct)

		Type Parameters:
			N: comparable
			E: comparable

		Adapter lets a caller retain its own node and edge arena IDs while using
		the common network-simplex implementation. Nodes and outgoing edges must be
		supplied in their Java iteration order.

		Fields (total 6)
			MinLength func(E) int
			Nodes []N
			Outgoing func(N) []E
			Source func(E) N
			Target func(E) N
			Weight func(E) float64
		As Inputs Of (at least one exported)
			func Layer[N, E](adapter Adapter[N, E], options Options) map[N]int

	 type Edge (struct)
		Edge is the Go counterpart of NEdge.

		Fields (total 6)
			Delta int
			ID int
			Origin any
			Source NodeID
			Target NodeID
			Weight float64
		Methods (only one)
			(*Edge) Other(node NodeID) NodeID
				Other returns the opposite endpoint of edge.

		As Outputs Of (at least one exported)
			func (*Graph).Edge(id EdgeID) *Edge

	 type EdgeID uint32 (basic type)

		As Outputs Of (at least 2)
			func (*Graph).AddEdge(source, target NodeID, weight float64, delta int) EdgeID
			func (*Node).ConnectedEdges() []EdgeID
		As Inputs Of (at least 2)
			func (*Graph).Edge(id EdgeID) *Edge
			func (*Graph).ReverseEdge(id EdgeID)

	 type Graph (struct)
		Graph stores network-simplex nodes and edges in deterministic arenas.

		Fields (only one)
			Nodes []NodeID
				Nodes is the mutable list ELK removes from and appends to while pruning
				subtrees. It intentionally differs from the immutable node arena.

		Methods (total 8)
			(*Graph) AddEdge(source, target NodeID, weight float64, delta int) EdgeID
				AddEdge creates an NEdge and registers it with both endpoints.

			(*Graph) AddNode() NodeID
				AddNode creates and appends an NNode.

			(*Graph) Edge(id EdgeID) *Edge
			(*Graph) EdgeCount() int
			(*Graph) IsAcyclic() bool
				IsAcyclic creates the same topological numbering as NGraph.isAcyclic and
				reports whether every edge points forward in it.

			(*Graph) MakeConnected() (NodeID, bool)
				MakeConnected adds one artificial root for a disconnected graph and joins
				each connected component to it with zero-weight, zero-delta edges. The
				second return value reports whether a root was created.

			(*Graph) Node(id NodeID) *Node
			(*Graph) ReverseEdge(id EdgeID)
				ReverseEdge reverses edge and updates endpoint incidence lists in the same
				order as NGraph.reverseEdge.

		As Outputs Of (at least one exported)
			func NewGraph() *Graph
		As Inputs Of (at least one exported)
			func ForGraph(graph *Graph) *NetworkSimplex

	 type NetworkSimplex (struct)
		NetworkSimplex determines an optimal weighted layering of an acyclic graph.

		Methods (total 4)
			(*NetworkSimplex) Execute()
				Execute computes the layering and stores each result in Node.Layer.

			(*NetworkSimplex) WithBalancing(balance bool) *NetworkSimplex
			(*NetworkSimplex) WithIterationLimit(limit int) *NetworkSimplex
			(*NetworkSimplex) WithPreviousLayering(nodeCounts []int) *NetworkSimplex
		As Outputs Of (at least 4)
			func ForGraph(graph *Graph) *NetworkSimplex
			func (*NetworkSimplex).WithBalancing(balance bool) *NetworkSimplex
			func (*NetworkSimplex).WithIterationLimit(limit int) *NetworkSimplex
			func (*NetworkSimplex).WithPreviousLayering(nodeCounts []int) *NetworkSimplex

	 type Node (struct)
		Node is the Go counterpart of NNode.

		Fields (total 5)
			ID int
			IncomingEdges []EdgeID
			Layer int
			Origin any
			OutgoingEdges []EdgeID
		Methods (only one)
			(*Node) ConnectedEdges() []EdgeID
				ConnectedEdges returns incoming edges followed by outgoing edges, matching
				NNode.getConnectedEdges' iteration order.

		As Outputs Of (at least one exported)
			func (*Graph).Node(id NodeID) *Node

	 type NodeID uint32 (basic type)
		NodeID and EdgeID are stable arena handles. Arena order is Java object
		creation order; Nodes separately preserves NGraph's mutable list order.

		As Outputs Of (at least 3)
			func (*Edge).Other(node NodeID) NodeID
			func (*Graph).AddNode() NodeID
			func (*Graph).MakeConnected() (NodeID, bool)
		As Inputs Of (at least 3)
			func (*Edge).Other(node NodeID) NodeID
			func (*Graph).AddEdge(source, target NodeID, weight float64, delta int) EdgeID
			func (*Graph).Node(id NodeID) *Node

	 type Options (struct)
		Options configures the callback-based Layer entry point.

		Fields (total 3)
			Balance bool
			IterationLimit int
			PreviousLayeringNodeCounts []int
		As Inputs Of (at least one exported)
			func Layer[N, E](adapter Adapter[N, E], options Options) map[N]int


Package-Level Functions (total 3)

	 func ForGraph(graph *Graph) *NetworkSimplex
	 func Layer[N, E](adapter Adapter[N, E], options Options) map[N]int

		Type Parameters:
			N: comparable
			E: comparable

		Layer maps a caller-owned acyclic graph into ELK's common graph, executes
		network simplex, and returns layers keyed by the original node IDs.

	 func NewGraph() *Graph

The pages are generated with Golds v0.8.7. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds.