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

final def +(label: Ontology): Node

def ++(graph: Graph): Unit

final def ==(arg0: Any): Boolean

lazy val @idIndex: Index

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

lazy val @typeIndex: Index

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

def _indexEdge[S, E](edge: GEdge[S, E]): Unit

def _indexNode(node: GNode): Unit

def _indexValue(value: GValue[_]): Unit

def add(graph: Graph): Unit

final def asInstanceOf[T0]: T0

def buildAsyncTraversersStream[Start <: ClassType[_], End <: ClassType[_], Steps <: HList, Out](traversal: Traversal[Start, End, Steps])(ct: ClassType[_]): Task[Stream[Out]]

def buildTraversersStream[Start <: ClassType[_], End <: ClassType[_], Steps <: HList, Out](traversal: Traversal[Start, End, Steps])(ct: ClassType[_]): Stream[Out]

def clone(): AnyRef

def close(): Unit

val computer: DefaultStreamComputer

def createEdge[S, E](id: Long, _from: GResource[S], key: Property, _to: GResource[E]): GEdge[S, E]

creates, stores and indexes an edge

def createEdge(id: Long, from: Long, key: Property, to: Long): GEdge[Any, Any]

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

def datatypeFromCache(iri: String): Option[DataType[_]]

def datatypeFromCache(id: Long): Option[DataType[_]]

val datatypes: AnyRef { ... /* 2 definitions in type refinement */ }

def deleteEdge(edge: GEdge[_, _]): Unit

deletes the Edge from the graph

def deleteNode(node: GNode): Unit

deletes the Node from the graph

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

delete in-/out-going edges from the resource

def deleteValue(value: GValue[_]): Unit

deletes the Value from the graph

val edgeStore: MemEdgeStore[MemNSGraph.this.type]

def edges: Edges

Edges A.K.A.

final def eq(arg0: AnyRef): Boolean

def equals(o: Any): Boolean

def finalize(): Unit

def g(graph: Graph*): Traversal[DataType[Graph], DataType[Graph], HNil]

def g: Traversal[DataType[Graph], DataType[Graph], HNil]

final def getClass(): Class[_]

def getClassType(node: Node): ClassType[_]

def getClassType(iri: String): Option[ClassType[_]]

def getDataType[T](iri: String)(implicit arg0: DefaultsToAny[T]): Option[DataType[T]]

def getDataTypes[T](id: Long, ids: Long*)(implicit arg0: DefaultsToAny[T]): List[DataType[T]]

def getExtendedByProperties(key: Property): List[Property]

Gets all properties which extend key

def getOntologies(id: Long, ids: Long*): List[Ontology]

def getOntologies(iri: String*): List[Ontology]

def getOntology(iri: String): Option[Ontology]

def getOrCreateNode(id: Long): GNode

def getProperties(id: Long, ids: Long*): List[Property]

def getProperties(iri: String*): List[Property]

def getProperty(iri: String): Option[Property]

lazy val hashCode: Int

lazy val idProvider: IdProvider

def init(): Unit

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

def newEdge(id: Long, from: Long, key: Property, to: Long): GEdge[Any, Any]

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

def newNode(id: Long): GNode

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

val nodeStore: MemNodeStore[MemNSGraph.this.type]

def nodes: Nodes

Nodes A.K.A.

final def notify(): Unit

final def notifyAll(): Unit

def ns: NameSpaceGraph

val ontologies: AnyRef { ... /* 2 definitions in type refinement */ }

def ontologyFromCache(iri: String): Option[Ontology]

def ontologyFromCache(id: Long): Option[Ontology]

val properties: AnyRef { ... /* 2 definitions in type refinement */ }

def propertyFromCache(iri: String): Option[Property]

def propertyFromCache(id: Long): Option[Property]

def propertyFromNode(node: _Node): Property

def resources: Resources

def storeClassType[CT <: ClassType[_]](classType: CT): Node

def storeDataType(dataType: DataType[_]): Node

def storeEdge(edge: GEdge[_, _]): Unit

def storeNode(node: GNode): Unit

def storeOntology(ontology: Ontology): Node

def storeProperty(property: Property): Node

def storeValue(value: GValue[_]): Unit

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

lazy val thisgraph: MemNSGraph.this.type

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

def toString(): String

def transaction: Transaction

creates new transaction

lazy val traversal: Traversal[DataType[Graph], DataType[Graph], HNil]

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