LNode

abstract val graph: LGraph

abstract def id: Long

final def !=(arg0: Any): Boolean

final def ##(): Int

def ---(f: (default.type) ⇒ structure.Property): PartialOutEdge[structure.Node]

def ---(key: structure.Property): PartialOutEdge[structure.Node]

def ---(key: String): PartialOutEdge[structure.Node]

def -|-(key: structure.Property): PartialOutEdge[structure.Node]

def <--(key: structure.Property): PartialInEdge[structure.Node]

def <--(key: String): PartialInEdge[structure.Node]

final def ==(arg0: Any): Boolean

def ===(o: Any): Boolean

def @id: String

def @ids: Set[String]

def @type: List[structure.ClassType[_]]

def _addIn(edge: structure.Edge[_, structure.Node]): Unit

def _addLabel(ontology: structure.Ontology): Task[Unit]

def _addOut(edge: structure.Edge[structure.Node, _]): Unit

def _cacheLabel(ontology: structure.Ontology): Unit

add ontology, do not store

var _lastinsync: Option[Long]

var _lastoutsync: Option[Long]

var _lastused: Long

def addBoth[V, R[T] <: structure.Resource[T]](key: structure.Property, value: R[V]): Task[(structure.Edge[structure.Node, V], structure.Edge[V, structure.Node])]

def addIn[V <: structure.ClassType[_]](key: structure.Property, value: V): Task[structure.Edge[structure.Node, structure.Node]]

def addIn[V, R[Z] <: structure.ClassType[Z]](key: structure.Property, dt: R[V], value: V)(implicit ev1: <:!<[V, structure.ClassType[_]]): Task[structure.Edge[V, structure.Node]]

def addIn[V, V0, VT0 <: structure.ClassType[_]](key: structure.Property, value: V)(implicit ev1: <:!<[V, structure.ClassType[_]], ct: Aux[V, V0, VT0]): Task[structure.Edge[V0, structure.Node]]

def addIn[V <: structure.ClassType[_]](key: String, value: V): Task[structure.Edge[structure.Node, structure.Node]]

def addIn[V, V0, VT0 <: structure.ClassType[_]](key: String, value: V)(implicit ev1: <:!<[V, structure.ClassType[_]], dt: Aux[V, V0, VT0]): Task[structure.Edge[V0, structure.Node]]

def addLabel(ontology: structure.Ontology): Task[Unit]

def addOut[V](key: structure.TypedProperty[V], value: V): Task[structure.Edge[structure.Node, V]]

def addOut[V <: structure.ClassType[_]](key: structure.Property, value: V): Task[structure.Edge[structure.Node, structure.Node]]

def addOut[V, R[Z] <: structure.ClassType[Z]](key: structure.Property, dt: R[V], value: V)(implicit ev1: <:!<[V, structure.ClassType[_]]): Task[structure.Edge[structure.Node, V]]

def addOut[V, V0, VT0 <: structure.ClassType[_]](key: structure.Property, value: V)(implicit ev1: <:!<[V, structure.ClassType[_]], ct: Aux[V, V0, VT0]): Task[structure.Edge[structure.Node, V0]]

def addOut[V <: structure.ClassType[_]](key: String, value: V): Task[structure.Edge[structure.Node, structure.Node]]

def addOut[V, V0, VT0 <: structure.ClassType[_]](key: String, value: V)(implicit ev1: <:!<[V, structure.ClassType[_]], dt: Aux[V, V0, VT0]): Task[structure.Edge[structure.Node, V0]]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equalValues(o: Any): Boolean

def equals(o: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def hasLabel[L](label: structure.ClassType[L]*): Option[structure.Resource[L]]

lazy val hashCode: Int

def in(key: structure.Property*): List[Any]

def in(f: (default.type) ⇒ structure.Property, ff: (default.type) ⇒ structure.Property*): List[Any]

def in(key: String, keys: String*): List[Any]

def inE(key: structure.Property*): List[structure.Edge[Any, structure.Node]]

def inE(f: (default.type) ⇒ structure.Property, ff: (default.type) ⇒ structure.Property*): List[structure.Edge[Any, structure.Node]]

def inE(key: String, keys: String*): List[structure.Edge[Any, structure.Node]]

def inEMap(key: structure.Property*): Map[structure.Property, List[structure.Edge[Any, structure.Node]]]

def inEMap(f: (default.type) ⇒ structure.Property, ff: (default.type) ⇒ structure.Property*): Map[structure.Property, List[structure.Edge[Any, structure.Node]]]

def inEMap(key: String, keys: String*): Map[structure.Property, List[structure.Edge[Any, structure.Node]]]

def inMap(key: structure.Property*): Map[structure.Property, List[Any]]

def inMap(f: (default.type) ⇒ structure.Property, ff: (default.type) ⇒ structure.Property*): Map[structure.Property, List[Any]]

def inMap(key: String, keys: String*): Map[structure.Property, List[Any]]

def iri: String

def iris: Set[String]

final def isInstanceOf[T0]: Boolean

def keys: Set[structure.Property]

def labels: List[structure.Ontology]

var memento: Long

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def out(key: structure.Property*): List[Any]

def out[V](key: structure.TypedProperty[V], keys: structure.TypedProperty[V]*): List[V]

def out(f: (default.type) ⇒ structure.Property, ff: (default.type) ⇒ structure.Property*): List[Any]

def out(key: String, keys: String*): List[Any]

def outE(key: structure.Property*): List[structure.Edge[structure.Node, Any]]

def outE[V](key: structure.TypedProperty[V], keys: structure.TypedProperty[V]*): List[structure.Edge[structure.Node, V]]

def outE(f: (default.type) ⇒ structure.Property, ff: (default.type) ⇒ structure.Property*): List[structure.Edge[structure.Node, Any]]

def outE(key: String, keys: String*): List[structure.Edge[structure.Node, Any]]

def outEMap(key: structure.Property*): Map[structure.Property, List[structure.Edge[structure.Node, Any]]]

def outEMap(f: (default.type) ⇒ structure.Property, ff: (default.type) ⇒ structure.Property*): Map[structure.Property, List[structure.Edge[structure.Node, Any]]]

def outEMap(key: String, keys: String*): Map[structure.Property, List[structure.Edge[structure.Node, Any]]]

def outMap(key: structure.Property*): Map[structure.Property, List[Any]]

def outMap(f: (default.type) ⇒ structure.Property, ff: (default.type) ⇒ structure.Property*): Map[structure.Property, List[Any]]

def outMap(key: String, keys: String*): Map[structure.Property, List[Any]]

def prettyPrint: String

def remove(): Task[Unit]

def removeIn(key: structure.Property): Task[Unit]

def removeIn[V >: structure.Node](edge: structure.Edge[_, V]): Task[Unit]

def removeLabel(classType: structure.Ontology): Unit

def removeOut(key: structure.Property): Task[Unit]

def removeOut[V >: structure.Node](edge: structure.Edge[V, _]): Task[Unit]

def sameResource(resource: structure.Resource[_]): Boolean

def self: structure.Resource[structure.Node]

var status: CacheStatus

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

def toString(): String

val value: structure.Node

final def wait(): Unit

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

final def wait(arg0: Long): Unit