LIndexGraph

Type Members

trait Edges extends RApi[Edge[_, _]]

Definition Classes
Graph
type GEdge[S, E] = _Edge[S, E] with LEdge[S, E]

Definition Classes
LGraph → Graph
type GNode = _Node with LNode

Definition Classes
LGraph → Graph
abstract type GResource[T] <: _Resource[T]

Definition Classes
Graph
type GValue[T] = _Value[T] with LValue[T]

Definition Classes
LGraph → Graph
trait Nodes extends RApi[Node]

Definition Classes
Graph
sealed trait RApi[T <: Resource[_]] extends AnyRef

Definition Classes
Graph
trait Resources extends RApi[Resource[_]]

Definition Classes
Graph
trait Values extends RApi[Value[_]]

Definition Classes
Graph
abstract class _Edge[S, E] extends _Resource[Edge[S, E]] with Edge[S, E]

Definition Classes
Graph
abstract class _Node extends _Resource[Node] with Node

Definition Classes
Graph
trait _Resource[+T] extends Resource[T]

Definition Classes
Graph
abstract class _Value[T] extends _Resource[T] with Value[T]

Definition Classes
Graph

Abstract Value Members

abstract def graph: LGraph

Definition Classes
LIndexGraph → IndexGraph
abstract def indexManager: IndexManager[LIndexGraph.this.type]
abstract def iri: String

Definition Classes
IriResource
abstract def storeManager: StoreManager[LIndexGraph.this.type]

Attributes
protected[lspace.lgraph]
Definition Classes
LGraph

Concrete Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
def *>[ST <: ClassType[_], ET <: ClassType[_], Segments <: HList, Steps <: HList, RSteps <: HList, Containers <: HList, F[_], Out, CT <: ClassType[Out], Out2](traversal: librarian.traversal.Traversal[ST, ET, Segments])(implicit flat: Aux[SegmentMapper.type, Segments, Steps], reverse: Aux[Steps, RSteps], f: Aux[RSteps, ContainerSteps.type, Containers], lf: Aux[Containers, ET, Out, CT], tw: Aux[ET, Out, Containers, Out2], guide: Guide[F], mapper: Mapper[F, Containers, Out]): FT

Definition Classes
Graph
final def +(label: Ontology): Node

Definition Classes
Graph
val ++: (structure.Graph) ⇒ structure.Graph

Definition Classes
Graph
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def @typeIndex: Index

Attributes
protected
Definition Classes
LIndexGraph → IndexGraph
def __[Start, End](implicit cltblStart: ClassTypeable[Start], cltblEnd: ClassTypeable[End]): librarian.traversal.Traversal[CT, CT, HNil]

Definition Classes
Graph
def add: (structure.Graph) ⇒ structure.Graph

Definition Classes
Graph
final def asInstanceOf[T0]: T0

Definition Classes
Any
implicit lazy val assistent: Assistent

Definition Classes
Graph
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def close(): CancelableFuture[Unit]

Definition Classes
LGraph → Graph
def createEdge[S, E](id: Long, from: GResource[S], key: Property, to: GResource[E]): GEdge[S, E]

Attributes
protected
Definition Classes
IndexGraph → Graph
def createEdge(id: Long, from: Long, key: Property, to: Long): GEdge[Any, Any]

Attributes
protected
Definition Classes
Graph
def createIndex(traversal: UntypedTraversal): Index

Attributes
protected
Definition Classes
LIndexGraph → IndexGraph
def createValue[T](_id: Long, _value: T, dt: DataType[T]): GValue[T]

Attributes
protected
Definition Classes
IndexGraph → Graph
def deleteEdge(edge: GEdge[_, _]): Unit

Attributes
protected
Definition Classes
IndexGraph → Graph
def deleteIndex(index: Index): Unit

Definition Classes
LIndexGraph → IndexGraph
def deleteNode(node: GNode): Unit

Attributes
protected
Definition Classes
IndexGraph → Graph
def deleteResource[T <: _Resource[_]](resource: T): Unit

Attributes
protected
Definition Classes
LGraph → Graph
def deleteValue(value: GValue[_]): Unit

Attributes
protected
Definition Classes
IndexGraph → Graph
lazy val edgeStore: LEdgeStore[LIndexGraph.this.type]

Attributes
protected[lspace.lgraph]
Definition Classes
LGraph → Graph
def edges: Edges

Definition Classes
Graph
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(o: Any): Boolean

Definition Classes
IriResource → AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def getIndex(traversal: UntypedTraversal): Option[Index]

Definition Classes
LIndexGraph → IndexGraph
def getOrCreateIndex(traversal: UntypedTraversal): Index

Definition Classes
IndexGraph
def getOrCreateNode(id: Long): GNode

Attributes
protected[lspace]
Definition Classes
LGraph → Graph
implicit lazy val guide: Guide[Observable]

Definition Classes
Graph
lazy val hashCode: Int

Definition Classes
Graph → AnyRef → Any
lazy val idProvider: IdProvider

Definition Classes
IndexGraph → Graph
lazy val indexCache: MemGraph
val indexes: HashMap[Long, Index]

Attributes
protected
lazy val init: CancelableFuture[Unit]

Definition Classes
IndexGraph → Graph
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def mergeNodes(nodes: Set[Node]): Task[Node]

Definition Classes
GraphUtils
def mergeValues[V](values: Set[Value[V]]): Task[Value[V]]

Definition Classes
GraphUtils
final def ne(arg0: AnyRef): Boolean

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

Attributes
protected[lspace.lgraph]
Definition Classes
LGraph → Graph
def newEdge[S, E](id: Long, from: GResource[S], key: Property, to: GResource[E]): GEdge[S, E]

Attributes
protected[lspace.lgraph]
Definition Classes
LGraph → Graph
def newNode(id: Long): GNode

Attributes
protected[lspace.lgraph]
Definition Classes
LGraph → Graph
def newValue[T](id: Long, value: T, label: DataType[T]): GValue[T]

Attributes
protected[lspace.lgraph]
Definition Classes
LGraph → Graph
lazy val nodeStore: LNodeStore[LIndexGraph.this.type]

Attributes
protected[lspace.lgraph]
Definition Classes
LGraph → Graph
def nodes: Nodes

Definition Classes
Graph
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def ns: LNSGraph

Definition Classes
LIndexGraph → IndexGraph → LGraph → Graph
def persist: CancelableFuture[Unit]

Definition Classes
Graph
def resources: Resources

Definition Classes
Graph
implicit def stepListToTraversal(steps: List[Step]): librarian.traversal.Traversal[ClassType[Any], ClassType[Any], HList]

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

Attributes
protected
Definition Classes
Graph
def storeNode(node: GNode): Unit

Attributes
protected[lspace.lgraph]
Definition Classes
LGraph → Graph
def storeValue(value: GValue[_]): Unit

Attributes
protected
Definition Classes
Graph
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
lazy val thisgraph: LIndexGraph.this.type

Definition Classes
Graph
def toString(): String

Definition Classes
Graph → AnyRef → Any
def transaction: Transaction

Definition Classes
LGraph → Graph
lazy val valueStore: LValueStore[LIndexGraph.this.type]

Attributes
protected[lspace.lgraph]
Definition Classes
LGraph → Graph
def values: Values

Definition Classes
Graph
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
object writeedge

Definition Classes
LGraph
object writenode

Definition Classes
LGraph
object writevalue

Definition Classes
LGraph

Deprecated Value Members

def g(): librarian.traversal.Traversal[ClassType[Any], ClassType[Any], HNil]

Definition Classes
Graph
Annotations
@deprecated
Deprecated
instead import lspace.g
lazy val traversal: librarian.traversal.Traversal[ClassType[Any], ClassType[Any], HNil]

Definition Classes
Graph
Annotations
@deprecated
Deprecated
instead import lspace.g

Related Doc: package lgraph

trait LIndexGraph extends LGraph with IndexGraph

Type Members

trait Edges extends RApi[Edge[_, _]]

type GEdge[S, E] = _Edge[S, E] with LEdge[S, E]

type GNode = _Node with LNode

abstract type GResource[T] <: _Resource[T]

type GValue[T] = _Value[T] with LValue[T]

trait Nodes extends RApi[Node]

sealed trait RApi[T <: Resource[_]] extends AnyRef

trait Resources extends RApi[Resource[_]]

trait Values extends RApi[Value[_]]

abstract class _Edge[S, E] extends _Resource[Edge[S, E]] with Edge[S, E]

abstract class _Node extends _Resource[Node] with Node

trait _Resource[+T] extends Resource[T]

abstract class _Value[T] extends _Resource[T] with Value[T]

Abstract Value Members

abstract def graph: LGraph

abstract def indexManager: IndexManager[LIndexGraph.this.type]

abstract def iri: String

abstract def storeManager: StoreManager[LIndexGraph.this.type]

Concrete Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def +(label: Ontology): Node

val ++: (structure.Graph) ⇒ structure.Graph

final def ==(arg0: Any): Boolean

def @typeIndex: Index

def __[Start, End](implicit cltblStart: ClassTypeable[Start], cltblEnd: ClassTypeable[End]): librarian.traversal.Traversal[CT, CT, HNil]

def add: (structure.Graph) ⇒ structure.Graph

final def asInstanceOf[T0]: T0

implicit lazy val assistent: Assistent

def clone(): AnyRef

def close(): CancelableFuture[Unit]

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

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

def createIndex(traversal: UntypedTraversal): Index

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

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

def deleteIndex(index: Index): Unit

def deleteNode(node: GNode): Unit

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

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

lazy val edgeStore: LEdgeStore[LIndexGraph.this.type]

def edges: Edges

final def eq(arg0: AnyRef): Boolean

def equals(o: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def getIndex(traversal: UntypedTraversal): Option[Index]

def getOrCreateIndex(traversal: UntypedTraversal): Index

def getOrCreateNode(id: Long): GNode

implicit lazy val guide: Guide[Observable]

lazy val hashCode: Int

lazy val idProvider: IdProvider

lazy val indexCache: MemGraph

val indexes: HashMap[Long, Index]

lazy val init: CancelableFuture[Unit]

final def isInstanceOf[T0]: Boolean

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

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

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]

lazy val nodeStore: LNodeStore[LIndexGraph.this.type]

def nodes: Nodes

final def notify(): Unit

final def notifyAll(): Unit

def ns: LNSGraph

def persist: CancelableFuture[Unit]

def resources: Resources

implicit def stepListToTraversal(steps: List[Step]): librarian.traversal.Traversal[ClassType[Any], ClassType[Any], HList]

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

def storeNode(node: GNode): Unit

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

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

lazy val thisgraph: LIndexGraph.this.type