MemNSGraph

abstract def graph: MemGraph

abstract def index: IndexGraph

abstract def iri: String

An empty uri means that there is no URI assigned.

final def !=(arg0: Any): Boolean

final def ##(): Int

def *>[ST <: structure.ClassType[_], End, ET[+Z] <: structure.ClassType[Z], Segments <: HList, Steps <: HList, RSteps <: HList, Containers <: HList, F[_]](traversal: librarian.traversal.Traversal[ST, ET[End], Segments])(implicit flat: Aux[SegmentMapper.type, Segments, Steps], reverse: Aux[Steps, RSteps], f: Aux[RSteps, ContainerSteps.type, Containers], guide: Guide[F], mapper: Mapper[F, Containers, End]): FT

final def +(label: structure.Ontology): Task[structure.Node]

val ++: (structure.Graph) ⇒ Task[structure.Graph]

final def ==(arg0: Any): Boolean

def @id: String

The @id is a IRI/URI identifier

val @idStore: MemValueStore[MemNSGraph.this.type]

def _createEdge(resource: structure.Resource[_], key: structure.Property, ct: structure.ClassType[_]): Task[Unit]

def add: (structure.Graph) ⇒ Task[structure.Graph]

final def asInstanceOf[T0]: T0

implicit lazy val assistent: Assistent

val classtypes: Classtypes

def clone(): AnyRef

def close(): Task[Unit]

def createEdge[S, E](id: Long, from: _Resource[S], key: structure.Property, to: _Resource[E]): Task[GEdge[S, E]]

creates, stores and indexes an edge

def createValue[T](_id: Long, _value: T, dt: datatype.DataType[T]): Task[GValue[T]]

val datatypes: Datatypes

def deleteEdge(edge: _Edge[_, _]): Task[Unit]

deletes the Edge from the graph

def deleteNode(node: _Node): Task[Unit]

deletes the Node from the graph

def deleteResource[T <: _Resource[_]](resource: T): Task[Unit]

delete in-/out-going edges from the resource

def deleteValue(value: _Value[_]): Task[Unit]

deletes the Value from the graph

val edgeStore: MemEdgeStore[MemNSGraph.this.type]

def edges: Edges

final def eq(arg0: AnyRef): Boolean

def equals(o: Any): Boolean

def executeTraversal[F[_]](traversal: librarian.traversal.Traversal[_ <: structure.ClassType[Any], _ <: structure.ClassType[Any], _ <: HList], guide: Guide[F]): F[Any]

def finalize(): Unit

final def getClass(): Class[_]

def getOrCreateNode(id: Long): Task[GNode]

implicit lazy val guide: Guide[Observable]

lazy val hashCode: Int

lazy val idProvider: IdProvider

def indexEdge[S, E](edge: _Edge[S, E]): Task[Unit]

def indexNode(node: _Node): Task[Unit]

lazy val init: Task[Unit]

final def isInstanceOf[T0]: Boolean

def mergeNodes(nodes: Set[structure.Node]): Task[structure.Node]

def mergeValues[V](values: Set[structure.Value[V]]): Task[structure.Value[V]]

final def ne(arg0: AnyRef): Boolean

def newEdge[S, E](id: Long, from: _Resource[S], key: structure.Property, to: _Resource[E]): GEdge[S, E]

val newEdgeLock: AnyRef

def newNode(id: Long): GNode

def newValue[T](id: Long, value: T, label: datatype.DataType[T]): GValue[T]

val newValueLock: AnyRef

val nodeStore: MemNodeStore[MemNSGraph.this.type]

def nodes: Nodes

final def notify(): Unit

final def notifyAll(): Unit

def ns: MemNSGraph.this.type

val ontologies: Ontologies

def persist: Task[Unit]

val properties: Properties

def purge: Task[Unit]

def resources: Resources

def storeEdge(edge: _Edge[_, _]): Task[Unit]

def storeNode(node: _Node): Task[Unit]

def storeValue(value: _Value[_]): Task[Unit]

final def synchronized[T0](arg0: ⇒ T0): T0

lazy val thisgraph: MemNSGraph.this.type

def toFile(path: String = "defaultname.json", process: (Observable[structure.Resource[_]], (String) ⇒ Unit) ⇒ Task[String]): Task[Unit]

def toString(): String

def transaction: Transaction

creates new transaction

val valueStore: MemValueStore[MemNSGraph.this.type]

def values: Values

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit