Package io.github.cfraser.graphit

Types

AcyclicException

class AcyclicException(edge: Edge<*>) : GraphException

AcyclicException is thrown when a path between the vertices would violate the acyclic constraint in the graph.

BasicEdge

data class BasicEdge<V : Any>(val source: V, val target: V) : Edge<V>

BasicEdge is an Edge implementation that only stores the source and target vertices.

BreadthFirst

class BreadthFirst<V : Any>(vertex: V) : TraversalStrategy<V>

BreadthFirst represents a breadth-first search of the Graph, beginning at the vertex.

DepthFirst

class DepthFirst<V : Any>(vertex: V) : TraversalStrategy<V>

DepthFirst represents a depth-first search of the Graph, beginning at the vertex.

Edge

interface Edge<V : Any>

An Edge connects source and target vertices in a Graph.

EdgeAlreadyExists

class EdgeAlreadyExists(edge: Edge<*>) : GraphException

EdgeAlreadyExists is thrown when an edge between the vertices already exists in the graph.

EdgeDsl

interface EdgeDsl<V : Any>

EdgeDsl empowers the fluent construction of Edge types.

EdgeNotFound

class EdgeNotFound(source: Any, target: Any) : GraphException

EdgeNotFound is thrown when an edge between the vertices is not found in the graph.

Feature

enum Feature : Enum<Feature>

Feature describes the qualities supported and enforced by a Graph. A Graph may have any combination of feature(s) or none.

Generic

interface Generic<T : Any>

Generic specifies that the edges in a Graph contain arbitrary attributes.

GenericEdge

data class GenericEdge<V : Any, T : Any>( val source: V, val target: V, val attributes: T) : Edge<V> , Generic<T>

GenericEdge is an Edge implementation which enables the storage of arbitrary attributes, in addition to the source and target vertices.

Graph

interface Graph<V : Any, E : Edge<V>>

Graph is a generic immutable graph data structure consisting of vertices and edges.

GraphBuilder

interface GraphBuilder<V : Any, E : Edge<V>> : EdgeDsl<V>

GraphBuilder enables the addition of vertices and edges to a Graph.

GraphException

sealed class GraphException : RuntimeException

GraphException is the base RuntimeException type representing erroneous Graph operations.

LoopException

object LoopException : GraphException

LoopException is thrown when an edge connects a vertex to itself.

NoPathExists

class NoPathExists(source: Any, target: Any) : GraphException

NoPathExists is thrown when no path between the vertices exists in the graph.

TraversalStrategy

sealed class TraversalStrategy<V : Any>

TraversalStrategy determines the order in which the vertices in a Graph are traversed.

UndirectedException

object UndirectedException : GraphException

UndirectedException is thrown when an undirected graph attempts to find strongly connected components.

VertexNotFound

class VertexNotFound(vertex: Any) : GraphException

VertexNotFound is thrown when an expected vertex is not found in the graph.

Vertices

typealias Vertices<V> = Pair<V, V>

Vertices is a vertex Pair which may, or may not, be connected by an Edge.

In a directed Graph, the order of the Vertices is consequential. Specifically, the Pair.first corresponds to the Edge.source, while Pair.second corresponds to the Edge.target.

Weighted

interface Weighted

Weighted specifies that the edges in a Graph are weighted.

WeightedEdge

data class WeightedEdge<V : Any>( val source: V, val target: V, val weight: Int) : Edge<V> , Weighted

WeightedEdge is an Edge implementation that captures a weight for the source to target connection.

WeightedGenericEdge

data class WeightedGenericEdge<V : Any, T : Any>( val source: V, val target: V, val weight: Int, val attributes: T) : Edge<V> , Weighted, Generic<T>

WeightedGenericEdge is an Edge implementation that is a combination of WeightedEdge and GenericEdge.

Functions

buildGraph

fun <V : Any, E : Edge<V>> buildGraph(vararg features: Feature = arrayOf(), builder: GraphBuilder<V, E>.() -> Unit): Graph<V, E>

Build a Graph instance.

Properties

isAcyclic

val Graph<*, *>.isAcyclic: Boolean

isAcyclic returns true if Feature.ACYCLIC is in the Graph.features.

isDirected

val Graph<*, *>.isDirected: Boolean

isDirected returns true if Feature.DIRECTED is in the Graph.features.

isUndirected

val Graph<*, *>.isUndirected: Boolean

isUndirected returns true if Feature.DIRECTED is not in the Graph.features.