StoreManager

abstract def close(): CancelableFuture[Unit]

finishes write-queue(s) and closes connection

abstract def deleteEdges(edges: List[G.GEdge[_, _]]): Task[_]

abstract def deleteNodes(nodes: List[G.GNode]): Task[_]

abstract def deleteValues(values: List[G.GValue[_]]): Task[_]

abstract def edgeById(id: Long): Option[G.GEdge[Any, Any]]

abstract def edgeByIri(iri: String): Stream[G.GEdge[Any, Any]]

abstract def edgeCount(): Long

abstract def edges: Stream[G.GEdge[Any, Any]]

abstract def edgesByFromId(fromId: Long): Stream[G.GEdge[Any, Any]]

abstract def edgesByFromIdAndKey(fromId: Long, key: Property): Stream[G.GEdge[Any, Any]]

abstract def edgesByFromIdAndKeyAndToId(fromId: Long, key: Property, toId: Long): Stream[G.GEdge[Any, Any]]

abstract def edgesByFromIdAndToId(fromId: Long, toId: Long): Stream[G.GEdge[Any, Any]]

abstract def edgesById(ids: List[Long]): Stream[G.GEdge[Any, Any]]

abstract def edgesByIri(iri: List[String]): Stream[G.GEdge[Any, Any]]

abstract def edgesByToId(toId: Long): Stream[G.GEdge[Any, Any]]

abstract def edgesByToIdAndKey(toId: Long, key: Property): Stream[G.GEdge[Any, Any]]

abstract def init: CancelableFuture[Unit]

abstract def nodeById(id: Long): Option[G.GNode]

abstract def nodeByIri(iri: String): Stream[G.GNode]

abstract def nodeCount(): Long

abstract def nodes: Stream[G.GNode]

abstract def nodesById(ids: List[Long]): Stream[G.GNode]

abstract def nodesByIri(iri: List[String]): Stream[G.GNode]

abstract def persist: CancelableFuture[Unit]

abstract def storeEdges(edges: List[G.GEdge[_, _]]): Task[_]

abstract def storeNodes(nodes: List[G.GNode]): Task[_]

abstract def storeValues(values: List[G.GValue[_]]): Task[_]

abstract def valueById(id: Long): Option[G.GValue[Any]]

abstract def valueByIri(iri: String): Stream[G.GValue[Any]]

abstract def valueByValue[T](value: T, dt: DataType[T]): Stream[G.GValue[T]]

abstract def valueCount(): Long

abstract def values: Stream[G.GValue[Any]]

abstract def valuesById(ids: List[Long]): Stream[G.GValue[Any]]

abstract def valuesByIri(iri: List[String]): Stream[G.GValue[Any]]

abstract def valuesByValue[T](values: List[(T, DataType[T])]): Stream[G.GValue[T]]

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def edgeStore: EdgeStore[G]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

val graph: G

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

def nodeStore: NodeStore[G]

final def notify(): Unit

final def notifyAll(): Unit

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

def toString(): String

def valueStore: ValueStore[G]

final def wait(): Unit

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

final def wait(arg0: Long): Unit