Index

Modules: grim/box, grim/entities, grim/graph, grim/io, grim/paths, grim/utils.

API symbols

`!=`:

• box: `!=`(self, other: Box): bool
• box: `!=`[T](self: Box; value: T): bool

`$`:

• box: `$`(b: Box): string
• box: `$`(t: Table[string, Box]): string
• entities: `$`(e: Edge): string
• entities: `$`(n: Node): string
• graph: `$`(self: Graph): string
• paths: `$`(m: Member): string
• paths: `$`(p: Path): string

`%`:

• box: `%`(t: tuple): Table[string, Box]

`>=`:

• box: `>=`(self, other: Box): bool
• box: `>=`[T](self: Box; value: T): bool

`>`:

• box: `>`(self, other: Box): bool
• box: `>`[T](self: Box; value: T): bool

`<=`:

• box: `<=`(self, other: Box): bool
• box: `<=`[T](self: Box; value: T): bool

`<`:

• box: `<`(self, other: Box): bool
• box: `<`[T](self: Box; value: T): bool

`.`:

• entities: `.`(map: Map; entry: untyped): untyped

`==`:

• box: `==`(self, other: Box): bool
• box: `==`[T](self: Box; value: T): bool
• entities: `==`(self, other: Edge): bool
• entities: `==`(self, other: Node): bool
• paths: `==`(self, other: Path): bool

`[]=`:

• entities: `[]=`(edge: Edge; property: string; value: Box)
• entities: `[]=`(node: Node; property: string; value: Box)

`[]`:

• entities: `[]`(edge: Edge; property: string): Box
• entities: `[]`(node: Node; property: string): Box

add:

• paths: add(pc: var PathCollection; p: Path)

addEdge:

• graph: addEdge(self: Graph; e: Edge): string
• graph: addEdge(self: Graph; A: Node; B: Node; label: string; data: Table[string, Box] = initTable(); oid: string = $genOid()): string
• graph: addEdge(self: Graph; A: string; B: string; label: string; data: Table[string, Box] = initTable(); oid: string = $genOid()): string

addNode:

• graph: addNode(self: Graph; n: Node): string
• graph: addNode(self: Graph; label: string; data: Table[string, Box] = initTable(); oid: string = $genOid()): string

between:

• entities: between(A, B: Node; direction: Direction = Direction.Out): (iterator (): Edge)

Box:

• box: Box

connected:

• entities: connected(A, B: Node; direction: Direction = Direction.Out): bool

contains:

• graph: contains(self: Graph; key: Edge): bool
• graph: contains(self: Graph; key: Node): bool
• graph: contains(self: Graph; key: string): bool

delEdge:

• graph: delEdge(self: Graph; oid: string): bool

delete:

• entities: delete(e: Edge)

delNode:

• graph: delNode(self: Graph; oid: string): bool

describe:

• box: describe(b: Box): string
• entities: describe(e: Edge; lineWidth: int = 100; propertyWidth: int = 20): string
• entities: describe(n: Node; lineWidth: int = 100; propertyWidth: int = 20): string
• graph: describe(g: Graph; lineWidth = 100): string

Direction:

• entities: Direction

Edge:

• entities: Edge

edge:

• graph: edge(self: Graph; edge: string): Edge

edgeLabels:

• graph: edgeLabels(self: Graph): seq[string]

edges:

• entities: edges(n: Node; direction: Direction = Direction.Out): (iterator (): Edge)
• graph: edges(self: Graph; labels: untyped = newSeq[string](); filter: untyped = true): ( iterator (): Edge)

edgesBetween:

• graph: edgesBetween(self: Graph; A: string; B: string; filter: untyped = true; direction: Direction = Direction.Out): (iterator (): Edge)

EntityOid:

• entities: EntityOid

first:

• paths: first(p: Path): Edge

follow:

• paths: follow(pc: PathCollection; edgeLabel, nodeLabel: string): PathCollection

getBool:

• box: getBool(b: Box): bool
• box: getBool(b: Box; default: bool): bool

getEnvOrRaise:

• utils: getEnvOrRaise(env: string): string

getFloat:

• box: getFloat(b: Box): float
• box: getFloat(b: Box; default: float): float

getInt:

• box: getInt(b: Box): BiggestInt
• box: getInt(b: Box; default: BiggestInt): BiggestInt

getStr:

• box: getStr(b: Box): string
• box: getStr(b: Box; default: string): string

Graph:

• graph: Graph

guessBox:

• box: guessBox(s: string): Box

hasEdge:

• graph: hasEdge(self: Graph; A: string; B: string; direction: Direction = Direction.Out): bool

hash:

• paths: hash(p: Path): Hash

initBox:

• box: initBox(): Box
• box: initBox(value: BiggestInt): Box
• box: initBox(value: bool): Box
• box: initBox(value: float): Box
• box: initBox(value: string): Box

initPathCollection:

• paths: initPathCollection(): PathCollection

isEmpty:

• box: isEmpty(b: Box): bool

items:

• paths: items(p: Path): Edge
• paths: items(pc: PathCollection): Path

keys:

• entities: keys[T: Node | Edge](obj: T): string

last:

• paths: last(p: Path): Edge

len:

• entities: len[T: Node | Edge](entity: T): int
• paths: len(p: Path): int
• paths: len(pc: PathCollection): int

loadYaml:

• io: loadYaml(fileName: string): Graph

navigate:

• graph: navigate(g: Graph; anchor: string): PathCollection

neighbors:

• entities: neighbors(n: Node; direction: Direction = Direction.Out): (iterator (): string)
• graph: neighbors(self: Graph; oid: string; filter: untyped = true; direction: Direction = Direction.Out): (iterator (): string)

newEdge:

• entities: newEdge(A: Node; B: Node; label: string; data: Table[string, Box] = initTable(); oid: string = $genOid()): Edge

newGraph:

• graph: newGraph(name: string = "graph"): Graph

newNode:

• entities: newNode(label: string; data: Table[string, Box] = initTable(); oid: string = $genOid()): Node

newPath:

• paths: newPath(anchor: Node): Path

Node:

• entities: Node

node:

• graph: node(self: Graph; node: string): Node

nodeLabels:

• graph: nodeLabels(self: Graph): seq[string]

nodes:

• graph: nodes(self: Graph; labels: untyped = newSeq[string](); filter: untyped = true): ( iterator (): Node)

nth:

• paths: nth(p: Path; n: int): Edge

numberOfEdges:

• graph: numberOfEdges(self: Graph): int

numberOfNeighbors:

• entities: numberOfNeighbors(n: Node; direction: Direction = Direction.Out): int

numberOfNodes:

• graph: numberOfNodes(self: Graph): int

pairs:

• entities: pairs[T: Node | Edge](obj: T): (string, Box)

PathCollection:

• paths: PathCollection

pop:

• paths: pop(p: Path): Edge

saveYaml:

• io: saveYaml(g: Graph; fileName: string; force_overwrite: bool = false)

sequalizeIt:

• utils: sequalizeIt(it: untyped): untyped

step:

• paths: step(pc: PathCollection; edgeLabel, nodeLabel: string): PathCollection

steps:

• paths: steps(pc: PathCollection; edgeLabel, nodeLabel: string; nsteps: int = 1): PathCollection

toMap:

• entities: toMap[T: Node | Edge](entity: T): Map

toTable:

• box: toTable(j: JsonNode): Table[string, Box]

update:

• box: update(b: var Box; value: BiggestInt)
• box: update(b: var Box; value: bool)
• box: update(b: var Box; value: float)
• box: update(b: var Box; value: string)
• entities: update[T](self: T; p: Table[string, Box]): string

values:

• entities: values[T: Node | Edge](obj: T): Box