graphs

README

Graph

A simple graph library written in Go.

Graphs are represented by an adjacency list combined with ports for each node. Paths can be found by using recursive depth first search.

Caution when using references

When using reference types as type parameter, always use the same pointer to reference the same logical object! As the type is being used as key in a map and compared for equality, this is very important.

Usage

Consider the following simple graph:

Define the nodes

one := graphs.NewNode[int, string](1)
two := graphs.NewNode[int, string](2)
three := graphs.NewNode[int, string](3)
four := graphs.NewNode[int, string](4)
five := graphs.NewNode[int, string](5)
six := graphs.NewNode[int, string](6)

Define inner port connections

one.ConnectBi("a", "b")
two.ConnectBi("a", "b")
two.ConnectBi("a", "c")
three.ConnectBi("a", "b")
four.ConnectBi("a", "b")
five.ConnectBi("a", "b")
five.ConnectBi("a", "c")
six.ConnectBi("a", "b")

Initialize the graph

graph := graphs.NewGraph[int, string]()
graphs.AddNode(one)
graphs.AddNode(two)
graphs.AddNode(three)
graphs.AddNode(four)
graphs.AddNode(five)
graphs.AddNode(six)

Define outer node connections

graphs.ConnectRefBi(1, "b", 2, "a")
graphs.ConnectRefBi(2, "b", 3, "a")
graphs.ConnectRefBi(2, "c", 4, "a")
graphs.ConnectRefBi(3, "b", 5, "b")
graphs.ConnectRefBi(4, "b", 5, "c")
graphs.ConnectRefBi(5, "a", 6, "a")

Find all paths

paths := graphs.FindRef(1, "b", 4, "b")

Documentation

Index

• type Connection
  • func NewConnection[I, P comparable](fromNode *Node[I, P], fromPort P, toNode *Node[I, P], toPort P) *Connection[I, P]
  • func (connection *Connection[I, P]) EqualNodes() bool
  • func (connection *Connection[I, P]) IsSelf() bool
  • func (connection *Connection[I, P]) String() string
• type Graph
  • func NewGraph[I, P comparable]() *Graph[I, P]
  • func (graph *Graph[I, P]) AddConnection(connection *Connection[I, P]) error
  • func (graph *Graph[I, P]) AddNode(node *Node[I, P])
  • func (graph *Graph[I, P]) Connect(fromNode *Node[I, P], fromPort P, toNode *Node[I, P], toPort P) error
  • func (graph *Graph[I, P]) ConnectBi(fromNode *Node[I, P], fromPort P, toNode *Node[I, P], toPort P) error
  • func (graph *Graph[I, P]) ConnectRef(fromRef I, fromPort P, toRef I, toPort P) error
  • func (graph *Graph[I, P]) ConnectRefBi(fromRef I, fromPort P, toRef I, toPort P) error
  • func (graph *Graph[I, P]) Find(fromNode *Node[I, P], fromPort P, toNode *Node[I, P], toPort P) [][]*Triple[*P, *Node[I, P], *P]
  • func (graph *Graph[I, P]) FindConnection(node *Node[I, P], port P) (*Connection[I, P], bool)
  • func (graph *Graph[I, P]) FindRef(fromRef I, fromPort P, toRef I, toPort P) ([][]*Triple[*P, *Node[I, P], *P], error)
• type Node
  • func NewNode[I, P comparable](id I) *Node[I, P]
  • func (node *Node[I, P]) Connect(from, to P)
  • func (node *Node[I, P]) ConnectBi(from, to P)
  • func (node *Node[I, P]) Equals(o *Node[I, P]) bool
  • func (node *Node[I, P]) Id() I
  • func (node *Node[I, P]) Next(port P) []P
  • func (node *Node[I, P]) String() string
• type Triple
  • func NewTriple[L, M, R comparable](l L, m M, r R) *Triple[L, M, R]
  • func (triple *Triple[L, M, R]) String() string

Types

type Connection

type Connection[I, P comparable] struct {
	FromNode *Node[I, P]
	FromPort P
	ToNode   *Node[I, P]
	ToPort   P
}

func NewConnection

func NewConnection[I, P comparable](fromNode *Node[I, P], fromPort P, toNode *Node[I, P], toPort P) *Connection[I, P]

func (*Connection[I, P]) EqualNodes

func (connection *Connection[I, P]) EqualNodes() bool

func (*Connection[I, P]) IsSelf

func (connection *Connection[I, P]) IsSelf() bool

func (*Connection[I, P]) String

func (connection *Connection[I, P]) String() string

type Graph

type Graph[I, P comparable] struct {
	// contains filtered or unexported fields
}

func NewGraph

func NewGraph[I, P comparable]() *Graph[I, P]

func (*Graph[I, P]) AddConnection

func (graph *Graph[I, P]) AddConnection(connection *Connection[I, P]) error

func (*Graph[I, P]) AddNode

func (graph *Graph[I, P]) AddNode(node *Node[I, P])

func (*Graph[I, P]) Connect

func (graph *Graph[I, P]) Connect(fromNode *Node[I, P], fromPort P, toNode *Node[I, P], toPort P) error

func (*Graph[I, P]) ConnectBi

func (graph *Graph[I, P]) ConnectBi(fromNode *Node[I, P], fromPort P, toNode *Node[I, P], toPort P) error

func (*Graph[I, P]) ConnectRef

func (graph *Graph[I, P]) ConnectRef(fromRef I, fromPort P, toRef I, toPort P) error

func (*Graph[I, P]) ConnectRefBi

func (graph *Graph[I, P]) ConnectRefBi(fromRef I, fromPort P, toRef I, toPort P) error

func (*Graph[I, P]) Find

func (graph *Graph[I, P]) Find(fromNode *Node[I, P], fromPort P, toNode *Node[I, P], toPort P) [][]*Triple[*P, *Node[I, P], *P]

func (*Graph[I, P]) FindConnection

func (graph *Graph[I, P]) FindConnection(node *Node[I, P], port P) (*Connection[I, P], bool)

func (*Graph[I, P]) FindRef

func (graph *Graph[I, P]) FindRef(fromRef I, fromPort P, toRef I, toPort P) ([][]*Triple[*P, *Node[I, P], *P], error)

type Node

type Node[I, P comparable] struct {
	// contains filtered or unexported fields
}

func NewNode

func NewNode[I, P comparable](id I) *Node[I, P]

func (*Node[I, P]) Connect

func (node *Node[I, P]) Connect(from, to P)

func (*Node[I, P]) ConnectBi

func (node *Node[I, P]) ConnectBi(from, to P)

func (*Node[I, P]) Equals

func (node *Node[I, P]) Equals(o *Node[I, P]) bool

func (*Node[I, P]) Id

func (node *Node[I, P]) Id() I

func (*Node[I, P]) Next

func (node *Node[I, P]) Next(port P) []P

func (*Node[I, P]) String

func (node *Node[I, P]) String() string

type Triple

type Triple[L, M, R comparable] struct {
	Left   L
	Middle M
	Right  R
}

func NewTriple

func NewTriple[L, M, R comparable](l L, m M, r R) *Triple[L, M, R]

func (*Triple[L, M, R]) String

func (triple *Triple[L, M, R]) String() string