MemEdge

abstract def from: Resource[S]

Origin of the edge

abstract val graph: MemGraph

Get the graph that this resource is within.

abstract def id: Long

id is a unique identifier of a resource in a graph

abstract def key: Property

abstract def to: Resource[E]

Destination of the edge

final def !=(arg0: Any): Boolean

final def ##(): Int

def ---(f: (default.type) ⇒ Property): PartialOutEdge[Edge[S, E]]

def ---(key: Property): PartialOutEdge[Edge[S, E]]

Creates a partial edge

def ---(key: String): PartialOutEdge[Edge[S, E]]

def -|-(key: Property): PartialOutEdge[Edge[S, E]]

Edge with Cardinality single

def <--(key: Property): PartialInEdge[Edge[S, E]]

def <--(key: String): PartialInEdge[Edge[S, E]]

final def ==(arg0: Any): Boolean

def ===(o: Any): Boolean

def @id: String

def @ids: Set[String]

def @type: List[ClassType[_]]

def _addIn(edge: Edge[_, Edge[S, E]]): Unit

def _addOut(edge: Edge[Edge[S, E], _]): Unit

def addBoth[V, R[T] <: Resource[T]](key: Property, value: R[V]): (Edge[Edge[S, E], V], Edge[V, Edge[S, E]])

def addIn[V <: ClassType[_]](key: Property, value: V): Edge[Node, Edge[S, E]]

def addIn[V, R[Z] <: ClassType[Z]](key: Property, dt: R[V], value: V)(implicit ev1: <:!<[V, ClassType[_]]): Edge[V, Edge[S, E]]

def addIn[V, V0, VT0 <: ClassType[_]](key: Property, value: V)(implicit ev1: <:!<[V, ClassType[_]], ct: Aux[V, V0, VT0]): Edge[V0, Edge[S, E]]

def addIn[V <: ClassType[_]](key: String, value: V): Edge[Node, Edge[S, E]]

def addIn[V, V0, VT0 <: ClassType[_]](key: String, value: V)(implicit ev1: <:!<[V, ClassType[_]], dt: Aux[V, V0, VT0]): Edge[V0, Edge[S, E]]

def addOut[V](key: TypedProperty[V], value: V): Edge[Edge[S, E], V]

def addOut[V <: ClassType[_]](key: Property, value: V): Edge[Edge[S, E], Node]

def addOut[V, R[Z] <: ClassType[Z]](key: Property, dt: R[V], value: V)(implicit ev1: <:!<[V, ClassType[_]]): Edge[Edge[S, E], V]

def addOut[V, V0, VT0 <: ClassType[_]](key: Property, value: V)(implicit ev1: <:!<[V, ClassType[_]], ct: Aux[V, V0, VT0]): Edge[Edge[S, E], V0]

def addOut[V <: ClassType[_]](key: String, value: V): Edge[Edge[S, E], Node]

def addOut[V, V0, VT0 <: ClassType[_]](key: String, value: V)(implicit ev1: <:!<[V, ClassType[_]], dt: Aux[V, V0, VT0]): Edge[Edge[S, E], V0]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equalValues(o: Any): Boolean

Compares if the edges the same origin, label and destination

def equals(o: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

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

filters the resource if it is labeled (including inherited/parent labels) with one or more of the provided labels

lazy val hashCode: Int

The hashcode is composed by the id-hash and the graph-iri-hash

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

Filters in-coming resources by the provided Property*

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

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

def inE(key: Property*): List[Edge[Any, Edge[S, E]]]

Filters in-coming resources by the provided Property*

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

def inE(key: String, keys: String*): List[Edge[Any, Edge[S, E]]]

def inEMap(key: Property*): Map[Property, List[Edge[Any, Edge[S, E]]]]

Filters and groups in-coming edges by the provided labels

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

def inEMap(key: String, keys: String*): Map[Property, List[Edge[Any, Edge[S, E]]]]

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

Filters and groups in-coming resources by the provided property-keys

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

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

def inV: Resource[E]

def iri: String

alias for @id

def iris: Set[String]

alias for @ids

final def isInstanceOf[T0]: Boolean

def keys: Set[Property]

def labels: List[Property]

alias for @type

var memento: Long

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

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

Filters out-going resources by the provided Property*

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

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

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

def outE(key: Property*): List[Edge[Edge[S, E], Any]]

Filters out-going resources by the provided Property*

def outE[V](key: TypedProperty[V], keys: TypedProperty[V]*): List[Edge[Edge[S, E], V]]

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

def outE(key: String, keys: String*): List[Edge[Edge[S, E], Any]]

def outEMap(key: Property*): Map[Property, List[Edge[Edge[S, E], Any]]]

Filters and groups out-going edges by the provided labels

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

def outEMap(key: String, keys: String*): Map[Property, List[Edge[Edge[S, E], Any]]]

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

Filters and groups out-going resources by the provided property-keys

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

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

def outV: Resource[S]

def prettyPrint: String

def remove(): Unit

def removeIn(key: Property): Unit

def removeIn[V >: Edge[S, E]](edge: Edge[_, V]): Unit

def removeOut(key: Property): Unit

def removeOut[V >: Edge[S, E]](edge: Edge[V, _]): Unit

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

def self: Resource[Edge[S, E]]

var status: CacheStatus

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

def toString(): String

val value: Edge[S, E]

The unboxed value

final def wait(): Unit

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

final def wait(arg0: Long): Unit