import "github.com/autom8ter/dagger/v3"

Package dagger is a collection of generic, concurrency safe datastructures including a Directed Acyclic Graph and others. Datastructures are implemented using generics in Go 1.18.

Supported Datastructures:

DAG: thread safe directed acyclic graph

Queue: unbounded thread safe fifo queue

Stack: unbounded thread safe lifo stack

BoundedQueue: bounded thread safe fifo queue with a fixed capacity

PriorityQueue: thread safe priority queue

HashMap: thread safe hashmap

Set: thread safe set

ChannelGroup: thread safe group of channels for broadcasting 1 value to N channels

MultiContext: thread safe context for coordinating the cancellation of multiple contexts

Borrower: thread safe object ownership manager

• func UniqueID(prefix string) string
• type BoundedQueue
  • func NewBoundedQueue[T any](maxSize int) *BoundedQueue[T]
  • func (q *BoundedQueue[T]) Close()
  • func (q *BoundedQueue[T]) Len() int
  • func (q *BoundedQueue[T]) Pop() (T, bool)
  • func (q *BoundedQueue[T]) PopContext(ctx context.Context) (T, bool)
  • func (q *BoundedQueue[T]) Push(val T) bool
  • func (q *BoundedQueue[T]) PushContext(ctx context.Context, val T) bool
  • func (q *BoundedQueue[T]) Range(fn func(element T) bool)
  • func (q *BoundedQueue[T]) RangeContext(ctx context.Context, fn func(element T) bool)
• type DAG
  • func NewDAG[T Node](opts ...DagOpt) (*DAG[T], error)
  • func (g *DAG[T]) Acyclic() bool
  • func (g *DAG[T]) BFS(ctx context.Context, reverse bool, start *GraphNode[T], search GraphSearchFunc[T]) error
  • func (g *DAG[T]) DFS(ctx context.Context, reverse bool, start *GraphNode[T], fn GraphSearchFunc[T]) error
  • func (g *DAG[T]) GetEdge(id string) (*GraphEdge[T], bool)
  • func (g *DAG[T]) GetEdges() []*GraphEdge[T]
  • func (g *DAG[T]) GetNode(id string) (*GraphNode[T], bool)
  • func (g *DAG[T]) GetNodes() []*GraphNode[T]
  • func (g *DAG[T]) GraphViz() (image.Image, error)
  • func (g *DAG[T]) HasEdge(id string) bool
  • func (g *DAG[T]) HasNode(id string) bool
  • func (g *DAG[T]) RangeEdges(fn func(e *GraphEdge[T]) bool)
  • func (g *DAG[T]) RangeNodes(fn func(n *GraphNode[T]) bool)
  • func (g *DAG[T]) SetNode(node Node) *GraphNode[T]
  • func (g *DAG[T]) Size() (int, int)
  • func (g *DAG[T]) TopologicalSort(reverse bool) ([]*GraphNode[T], error)
• type DagOpt
  • func WithVizualization() DagOpt
• type GraphEdge
  • func (n *GraphEdge[T]) From() *GraphNode[T]
  • func (n *GraphEdge[T]) ID() string
  • func (n *GraphEdge[T]) Metadata() map[string]string
  • func (n *GraphEdge[T]) Relationship() string
  • func (n *GraphEdge[T]) SetMetadata(metadata map[string]string)
  • func (n *GraphEdge[T]) To() *GraphNode[T]
• type GraphNode
  • func (n *GraphNode[T]) Ancestors(fn func(node *GraphNode[T]) bool)
  • func (n *GraphNode[T]) BFS(ctx context.Context, reverse bool, fn GraphSearchFunc[T]) error
  • func (n *GraphNode[T]) DFS(ctx context.Context, reverse bool, fn GraphSearchFunc[T]) error
  • func (n *GraphNode[T]) Descendants(fn func(node *GraphNode[T]) bool)
  • func (n *GraphNode[T]) EdgesFrom(relationship string, fn func(e *GraphEdge[T]) bool)
  • func (n *GraphNode[T]) EdgesTo(relationship string, fn func(e *GraphEdge[T]) bool)
  • func (n *GraphNode[T]) Graph() *DAG[T]
  • func (n *GraphNode[T]) IsConnectedTo(node *GraphNode[T]) bool
  • func (n *GraphNode[T]) Remove() error
  • func (n *GraphNode[T]) RemoveEdge(edgeID string)
  • func (n *GraphNode[T]) SetEdge(relationship string, toNode Node, metadata map[string]string) (*GraphEdge[T], error)
• type GraphSearchFunc
• type HashMap
  • func NewHashMap[K comparable, V any]() *HashMap[K, V]
  • func (n *HashMap[K, V]) Clear()
  • func (n *HashMap[K, V]) Delete(key K)
  • func (n *HashMap[K, V]) Exists(key K) bool
  • func (n *HashMap[K, V]) Filter(f func(key K, value V) bool) *HashMap[K, V]
  • func (n *HashMap[K, V]) Get(key K) (V, bool)
  • func (n *HashMap[K, V]) Keys() []K
  • func (n *HashMap[K, V]) Len() int
  • func (n *HashMap[K, V]) Map() map[K]V
  • func (n *HashMap[K, V]) Range(f func(key K, value V) bool)
  • func (n *HashMap[K, V]) Set(key K, value V)
  • func (n *HashMap[K, V]) Values() []V
• type Node
• type PriorityQueue
  • func NewPriorityQueue[T any]() *PriorityQueue[T]
  • func (q *PriorityQueue[T]) Len() int
  • func (q *PriorityQueue[T]) Peek() (T, bool)
  • func (q *PriorityQueue[T]) Pop() (T, bool)
  • func (q *PriorityQueue[T]) Push(item T, weight float64)
  • func (q *PriorityQueue[T]) UpdatePriority(value T, priority float64)
• type Queue
  • func NewQueue[T any]() *Queue[T]
  • func (s *Queue[T]) Len() int
  • func (s *Queue[T]) Peek() (T, bool)
  • func (s *Queue[T]) Pop() (T, bool)
  • func (s *Queue[T]) Push(f T)
  • func (q *Queue[T]) Range(fn func(element T) bool)
  • func (q *Queue[T]) RangeUntil(fn func(element T) bool, done chan struct{})
• type Set
  • func NewSet[T comparable]() *Set[T]
  • func (s *Set[T]) Add(val T)
  • func (s *Set[T]) Contains(val T) bool
  • func (s *Set[T]) Len() int
  • func (s *Set[T]) Range(fn func(element T) bool)
  • func (s *Set[T]) Remove(val T)
  • func (s *Set[T]) Sort(lessFunc func(i T, j T) bool) []T
  • func (s *Set[T]) Values() []T
• type Stack
  • func NewStack[T any]() *Stack[T]
  • func (s *Stack[T]) Clear()
  • func (s *Stack[T]) Len() int
  • func (s *Stack[T]) Peek() (T, bool)
  • func (s *Stack[T]) Pop() (T, bool)
  • func (s *Stack[T]) Push(f T)
  • func (s *Stack[T]) Range(fn func(element T) bool)
  • func (s *Stack[T]) RangeUntil(fn func(element T) bool, done chan struct{})
  • func (s *Stack[T]) Sort(lessFunc func(i T, j T) bool) []T
  • func (s *Stack[T]) Values() []T

func UniqueID(prefix string) string

UniqueID returns a unique identifier with the given prefix

BoundedQueue is a basic FIFO BoundedQueue based on a buffered channel

type BoundedQueue[T any] struct {
    // contains filtered or unexported fields
}

func NewBoundedQueue[T any](maxSize int) *BoundedQueue[T]

NewBoundedQueue returns a new BoundedQueue with the given max size. When the max size is reached, the queue will block until a value is removed. If maxSize is 0, the queue will always block until a value is removed. The BoundedQueue is concurrent-safe.

func (q *BoundedQueue[T]) Close()

Close closes the BoundedQueue channel.

func (q *BoundedQueue[T]) Len() int

Len returns the number of elements in the BoundedQueue.

func (q *BoundedQueue[T]) Pop() (T, bool)

Pop removes and returns an element from the beginning of the BoundedQueue.

func (q *BoundedQueue[T]) PopContext(ctx context.Context) (T, bool)

PopContext removes and returns an element from the beginning of the BoundedQueue. If no element is available, it will block until an element is available or the context is cancelled.

func (q *BoundedQueue[T]) Push(val T) bool

Push adds an element to the end of the BoundedQueue and returns a channel that will block until the element is added. If the queue is full, it will block until an element is removed.

func (q *BoundedQueue[T]) PushContext(ctx context.Context, val T) bool

PushContext adds an element to the end of the BoundedQueue and returns a channel that will block until the element is added. If the queue is full, it will block until an element is removed or the context is cancelled.

func (q *BoundedQueue[T]) Range(fn func(element T) bool)

Range executes a provided function once for each BoundedQueue element until it returns false.

func (q *BoundedQueue[T]) RangeContext(ctx context.Context, fn func(element T) bool)

RangeContext executes a provided function once for each BoundedQueue element until it returns false or a value is sent to the done channel. Use this function when you want to continuously process items from the queue until a done signal is received.

DAG is a concurrency safe, mutable, in-memory directed graph

type DAG[T Node] struct {
    // contains filtered or unexported fields
}

func NewDAG[T Node](opts ...DagOpt) (*DAG[T], error)

NewDAG creates a new Directed Acyclic Graph instance

func (g *DAG[T]) Acyclic() bool

Acyclic returns true if the graph contains no cycles.

func (g *DAG[T]) BFS(ctx context.Context, reverse bool, start *GraphNode[T], search GraphSearchFunc[T]) error

BFS executes a depth first search on the graph starting from the current node. The reverse parameter determines whether the search is reversed or not. The fn parameter is a function that is called on each node in the graph. If the function returns false, the search is stopped.

func (g *DAG[T]) DFS(ctx context.Context, reverse bool, start *GraphNode[T], fn GraphSearchFunc[T]) error

DFS executes a depth first search on the graph starting from the current node. The reverse parameter determines whether the search is reversed or not. The fn parameter is a function that is called on each node in the graph. If the function returns false, the search is stopped.

func (g *DAG[T]) GetEdge(id string) (*GraphEdge[T], bool)

GetEdge returns the edge with the given id

func (g *DAG[T]) GetEdges() []*GraphEdge[T]

GetEdges returns all edges in the graph

func (g *DAG[T]) GetNode(id string) (*GraphNode[T], bool)

GetNode returns the node with the given id

func (g *DAG[T]) GetNodes() []*GraphNode[T]

GetNodes returns all nodes in the graph

func (g *DAG[T]) GraphViz() (image.Image, error)

GraphViz returns a graphviz image

func (g *DAG[T]) HasEdge(id string) bool

HasEdge returns true if the edge with the given id exists in the graph

func (g *DAG[T]) HasNode(id string) bool

HasNode returns true if the node with the given id exists in the graph

func (g *DAG[T]) RangeEdges(fn func(e *GraphEdge[T]) bool)

RangeEdges iterates over all edges in the graph

func (g *DAG[T]) RangeNodes(fn func(n *GraphNode[T]) bool)

RangeNodes iterates over all nodes in the graph

func (g *DAG[T]) SetNode(node Node) *GraphNode[T]

SetNode sets a node in the graph - it will use the node's ID as the key and overwrite any existing node with the same ID

func (g *DAG[T]) Size() (int, int)

Size returns the number of nodes and edges in the graph

func (g *DAG[T]) TopologicalSort(reverse bool) ([]*GraphNode[T], error)

DagOpt is an option for configuring a DAG

type DagOpt func(*dagOpts)

func WithVizualization() DagOpt

WithVizualization enables graphviz visualization on the DAG

GraphEdge is a relationship between two nodes

type GraphEdge[T Node] struct {
    // contains filtered or unexported fields
}

func (n *GraphEdge[T]) From() *GraphNode[T]

From returns the from node of the edge

func (n *GraphEdge[T]) ID() string

ID returns the unique identifier of the node

func (n *GraphEdge[T]) Metadata() map[string]string

Metadata returns the metadata of the node

func (n *GraphEdge[T]) Relationship() string

Relationship returns the relationship between the two nodes

func (n *GraphEdge[T]) SetMetadata(metadata map[string]string)

SetMetadata sets the metadata of the node

func (n *GraphEdge[T]) To() *GraphNode[T]

To returns the to node of the edge

GraphNode is a node in the graph. It can be connected to other nodes via edges.

type GraphNode[T Node] struct {
    Node
    // contains filtered or unexported fields
}

func (n *GraphNode[T]) Ancestors(fn func(node *GraphNode[T]) bool)

Ancestors returns the ancestors of the current node

func (n *GraphNode[T]) BFS(ctx context.Context, reverse bool, fn GraphSearchFunc[T]) error

BFS performs a breadth-first search on the graph starting from the current node

func (n *GraphNode[T]) DFS(ctx context.Context, reverse bool, fn GraphSearchFunc[T]) error

DFS performs a depth-first search on the graph starting from the current node

func (n *GraphNode[T]) Descendants(fn func(node *GraphNode[T]) bool)

Descendants returns the descendants of the current node

func (n *GraphNode[T]) EdgesFrom(relationship string, fn func(e *GraphEdge[T]) bool)

EdgesFrom iterates over the edges from the current node to other nodes with the given relationship. If the relationship is empty, all relationships will be iterated over.

func (n *GraphNode[T]) EdgesTo(relationship string, fn func(e *GraphEdge[T]) bool)

EdgesTo iterates over the edges from other nodes to the current node with the given relationship. If the relationship is empty, all relationships will be iterated over.

func (n *GraphNode[T]) Graph() *DAG[T]

DirectedGraph returns the graph the node belongs to

func (n *GraphNode[T]) IsConnectedTo(node *GraphNode[T]) bool

IsConnectedTo returns true if the current node is connected to the given node in any direction

func (n *GraphNode[T]) Remove() error

Remove removes the current node from the graph

func (n *GraphNode[T]) RemoveEdge(edgeID string)

RemoveEdge removes an edge from the current node by edgeID

func (n *GraphNode[T]) SetEdge(relationship string, toNode Node, metadata map[string]string) (*GraphEdge[T], error)

SetEdge sets an edge from the current node to the node with the given nodeID. If the nodeID does not exist, an error is returned. If the edgeID is empty, a unique id will be generated. If the metadata is nil, an empty map will be used.

GraphSearchFunc is a function that is called on each node in the graph during a search

type GraphSearchFunc[T Node] func(ctx context.Context, relationship string, node *GraphNode[T]) bool

HashMap is a thread safe map

type HashMap[K comparable, V any] struct {
    // contains filtered or unexported fields
}

func NewHashMap[K comparable, V any]() *HashMap[K, V]

NewHashMap creates a new generic hash map

func (n *HashMap[K, V]) Clear()

Clear clears the map

func (n *HashMap[K, V]) Delete(key K)

Delete deletes the key from the map

func (n *HashMap[K, V]) Exists(key K) bool

Exists returns true if the key exists in the map

func (n *HashMap[K, V]) Filter(f func(key K, value V) bool) *HashMap[K, V]

Filter returns a new hashmap with the values that return true from the function

func (n *HashMap[K, V]) Get(key K) (V, bool)

Get gets the value from the key

func (n *HashMap[K, V]) Keys() []K

Keys returns a copy of the keys in the map as a slice

func (n *HashMap[K, V]) Len() int

Len returns the length of the map

func (n *HashMap[K, V]) Map() map[K]V

Map returns a copy of the hashmap as a map[string]T

func (n *HashMap[K, V]) Range(f func(key K, value V) bool)

Range ranges over the map with a function until false is returned

func (n *HashMap[K, V]) Set(key K, value V)

Set sets the key to the value

func (n *HashMap[K, V]) Values() []V

Values returns a copy of the values in the map as a slice

Node is a node in the graph. It can be connected to other nodes via edges.

type Node interface {
    // ID returns the unique identifier of the node
    ID() string
    // Metadata returns the metadata of the node
    Metadata() map[string]string
    // SetMetadata sets the metadata of the node
    SetMetadata(metadata map[string]string)
}

PriorityQueue is a thread safe priority queue

type PriorityQueue[T any] struct {
    // contains filtered or unexported fields
}

func NewPriorityQueue[T any]() *PriorityQueue[T]

NewPriorityQueue creates a new priority queue

func (q *PriorityQueue[T]) Len() int

Len returns the length of the queue

func (q *PriorityQueue[T]) Peek() (T, bool)

Peek returns the next item in the queue without removing it

func (q *PriorityQueue[T]) Pop() (T, bool)

Pop pops an item off the queue

func (q *PriorityQueue[T]) Push(item T, weight float64)

Push pushes an item onto the queue

func (q *PriorityQueue[T]) UpdatePriority(value T, priority float64)

Queue is a thread safe non-blocking queue

type Queue[T any] struct {
    // contains filtered or unexported fields
}

func NewQueue[T any]() *Queue[T]

NewQueue returns a new Queue

func (s *Queue[T]) Len() int

Len returns the length of the queue

func (s *Queue[T]) Peek() (T, bool)

Peek returns the next item in the queue without removing it

func (s *Queue[T]) Pop() (T, bool)

Pop and return top element of Queue. Return false if Queue is empty.

func (s *Queue[T]) Push(f T)

Push a new value onto the Queue

func (q *Queue[T]) Range(fn func(element T) bool)

Range executes a provided function once for each Queue element until it returns false or the Queue is empty.

func (q *Queue[T]) RangeUntil(fn func(element T) bool, done chan struct{})

RangeUntil executes a provided function once for each Queue element until it returns false or a value is sent on the done channel. Use this function when you want to continuously process items from the queue until a done signal is received.

Set is a basic thread-safe Set implementation.

type Set[T comparable] struct {
    // contains filtered or unexported fields
}

func NewSet[T comparable]() *Set[T]

NewSet returns a new Set with the given initial size.

func (s *Set[T]) Add(val T)

Add adds an element to the Set.

func (s *Set[T]) Contains(val T) bool

Contains returns true if the Set contains the element.

func (s *Set[T]) Len() int

Len returns the number of elements in the Set.

func (s *Set[T]) Range(fn func(element T) bool)

Range executes a provided function once for each Set element until it returns false.

func (s *Set[T]) Remove(val T)

Remove removes an element from the Set.

func (s *Set[T]) Sort(lessFunc func(i T, j T) bool) []T

Sort returns the values of the set as an array sorted by the provided less function

func (s *Set[T]) Values() []T

Values returns the values of the set as an array

Stack is a basic LIFO Stack

type Stack[T any] struct {
    // contains filtered or unexported fields
}

func NewStack[T any]() *Stack[T]

NewStack returns a new Stack instance

func (s *Stack[T]) Clear()

Clear removes all elements from the Stack

func (s *Stack[T]) Len() int

Len returns the number of elements in the Stack.

func (s *Stack[T]) Peek() (T, bool)

Peek returns the top element of the Stack without removing it. Return false if Stack is empty.

func (s *Stack[T]) Pop() (T, bool)

Pop removes and return top element of Stack. Return false if Stack is empty.

func (s *Stack[T]) Push(f T)

Push a new value onto the Stack (LIFO)

func (s *Stack[T]) Range(fn func(element T) bool)

Range executes a provided function once for each Stack element until it returns false.

func (s *Stack[T]) RangeUntil(fn func(element T) bool, done chan struct{})

RangeUntil executes a provided function once after calling Pop on the stack until the function returns false or a value is sent on the done channel. Use this function when you want to continuously process items from the stack until a done signal is received.

func (s *Stack[T]) Sort(lessFunc func(i T, j T) bool) []T

Sort returns the values of the stack as an array sorted by the provided less function

func (s *Stack[T]) Values() []T

Values returns the values of the stack as an array

Generated by gomarkdoc