graph

Documentation

Index

• type Edge
  • func BasicEdge(id ID, attributes Map, from, to Node) Edge
• type Edges
  • func (e Edges) AddEdge(edge Edge)
  • func (e Edges) DelEdge(id ID)
  • func (e Edges) Filter(fn func(e Edge) bool) []Edge
  • func (e Edges) FilterType(typ string, fn func(e Edge) bool) []Edge
  • func (e Edges) GetEdge(id ID) (Edge, bool)
  • func (e Edges) HasEdge(id ID) bool
  • func (e Edges) Len(typ string) int
  • func (e Edges) Range(fn func(e Edge) bool)
  • func (e Edges) RangeType(typ string, fn func(e Edge) bool)
  • func (e Edges) Types() []string
• type Graph
  • func NewGraph() Graph
• type ID
  • func BasicID(typ string, id string) ID
• type Map
  • func (m Map) Copy() Map
  • func (m Map) Del(k interface{})
  • func (m Map) Exists(key interface{}) bool
  • func (m Map) Filter(filter func(k, v interface{}) bool) Map
  • func (m Map) Get(k interface{}) (interface{}, bool)
  • func (m Map) Intersection(other Map) Map
  • func (m Map) Range(iterator func(k, v interface{}) bool)
  • func (m Map) Set(k, v interface{})
  • func (m Map) Union(other Map) Map
• type Node
  • func BasicNode(id ID, attributes Map) Node

Types

type Edge

type Edge interface {
	// An edge implements Node because it has an Identifier and attributes
	Node
	// From returns the root node of the edge
	From() Node
	// To returns the target node of the edge
	To() Node
}

Edge is a relationship between two nodes

func BasicEdge

func BasicEdge(id ID, attributes Map, from, to Node) Edge

type Edges

type Edges map[string]map[string]Edge

Edges is a map of edges. Edges are not concurrency safe.

func (Edges) AddEdge

func (e Edges) AddEdge(edge Edge)

AddEdge adds the edge to the map

func (Edges) DelEdge

func (e Edges) DelEdge(id ID)

DelEdge deletes the edge

func (Edges) Filter

func (e Edges) Filter(fn func(e Edge) bool) []Edge

Filter executes the function over every edge. If the function returns true, the edges will be added to the returned array of edges.

func (Edges) FilterType

func (e Edges) FilterType(typ string, fn func(e Edge) bool) []Edge

FilterType executes the function over every edge of the given type. If the function returns true, the edges will be added to the returned array of edges.

func (Edges) GetEdge

func (e Edges) GetEdge(id ID) (Edge, bool)

GetEdge gets an edge by id

func (Edges) HasEdge

func (e Edges) HasEdge(id ID) bool

HasEdge returns true if the edge exists

func (Edges) Len

func (e Edges) Len(typ string) int

Len returns the number of edges of the given type

func (Edges) Range

func (e Edges) Range(fn func(e Edge) bool)

Range executes the function over every edge. If the function returns false, the iteration stops.

func (Edges) RangeType

func (e Edges) RangeType(typ string, fn func(e Edge) bool)

RangeType executes the function over a list of edges with the given type. If the function returns false, the iteration stops.

func (Edges) Types

func (e Edges) Types() []string

type Graph

type Graph interface {
	// AddNode adds a single node to the graph
	AddNode(n Node)
	// AddNodes adds multiple nodes to the graph
	AddNodes(nodes ...Node)
	// GetNode gets a node from the graph if it exists
	GetNode(id ID) (Node, bool)
	// DelNode deletes the nodes and it's edges
	DelNode(id ID)
	// HasNode returns true if the node exists in the graph
	HasNode(id ID) bool
	// NodeTypes returns an array of Node types that exist in the graph
	NodeTypes() []string
	// RangeNodeTypes ranges over every node of the given type until the given function returns false
	RangeNodeTypes(typ string, fn func(n Node) bool)
	// RangeNodes ranges over every node until the given function returns false
	RangeNodes(fn func(n Node) bool)
	// AddEdge adds an edge to the graph between the two nodes. It returns an error if one of the nodes does not exist.
	AddEdge(e Edge) error
	// AddEdges adds all of the edges to the graph
	AddEdges(e Edges) error
	// GetEdge gets the edge by id if it exists
	GetEdge(id ID) (Edge, bool)
	// HasEdge returns true if the edge exists in the graph
	HasEdge(id ID) bool
	// DelEdge deletes the edge
	DelEdge(id ID)
	// DelEdges deletes all the edges at once
	DelEdges(e Edges) error
	// RangeEdges ranges over every edge until the given function returns false
	RangeEdges(fn func(e Edge) bool)
	// RangeEdgeTypes ranges over every edge of the given type until the given function returns false
	RangeEdgeTypes(typ string, fn func(e Edge) bool)
	// EdgesFrom returns all of the edges the point from the given node identifier
	EdgesFrom(id ID) (Edges, bool)
	// EdgesTo returns all of the edges the point to the given node identifier
	EdgesTo(id ID) (Edges, bool)
	// EdgeTypes returns all of the edge types in the Graph
	EdgeTypes() []string
	// Close removes all entries from the cache
	Close()
}

Graph is a concurrency safe directed Graph datastructure

func NewGraph

func NewGraph() Graph

type ID

type ID interface {
	// ID returns a string id
	ID() string
	// Type returns the string type
	Type() string
	// String returns a concatenation of id and type
	String() string
}

func BasicID

func BasicID(typ string, id string) ID

if id is empty, a random id will be assigned

type Map

type Map map[interface{}]interface{}

Map is a functional map for storing arbitrary data. It is not concurrency safe

func (Map) Copy

func (m Map) Copy() Map

Copy creates a replica of the Map

func (Map) Del

func (m Map) Del(k interface{})

Del deletes the entry from the map by key

func (Map) Exists

func (m Map) Exists(key interface{}) bool

Exists returns true if the key exists in the map

func (Map) Filter

func (m Map) Filter(filter func(k, v interface{}) bool) Map

Filter returns a map of the values that return true from the filter function

func (Map) Get

func (m Map) Get(k interface{}) (interface{}, bool)

Get gets an entry from the map by key

func (Map) Intersection

func (m Map) Intersection(other Map) Map

Intersection returns the values that exist in both maps ref: https://en.wikipedia.org/wiki/Intersection_(set_theory)#:~:text=In%20mathematics%2C%20the%20intersection%20of,that%20also%20belong%20to%20A).

func (Map) Range

func (m Map) Range(iterator func(k, v interface{}) bool)

Range iterates over the map with the function. If the function returns false, the iteration exits.

func (Map) Set

func (m Map) Set(k, v interface{})

Set set an entry in the map

func (Map) Union

func (m Map) Union(other Map) Map

Union returns the all values in both maps ref: https://en.wikipedia.org/wiki/Union_(set_theory)

type Node

type Node interface {
	ID
	// Attributes returns arbitrary data found in the node(if it exists)
	Attributes() Map
}

Node is a single element in the Graph. It may be connected to other Nodes via Edges

func BasicNode

func BasicNode(id ID, attributes Map) Node