StoreManager

abstract def close(): Task[Unit]

finishes write-queue(s) and closes connection

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

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

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

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

abstract def edgeCount(): Task[Long]

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

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

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

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

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

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

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

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

abstract def init: Task[Unit]

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

abstract def nodeCount(): Task[Long]

abstract def nodes: Observable[G.GNode]

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

abstract def persist: Task[Unit]

abstract def purge: Task[Unit]

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

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

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

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

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

abstract def valueCount(): Task[Long]

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

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

abstract def valuesByValue[T](values: List[(T, datatype.DataType[T])]): Observable[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