AsymmetricEdge

final def !=(arg0: Any): Boolean

final def ##(): Int

def +=(t: T, u: U): LinkedHashSet[NodeInstance[T]]

final def ==(arg0: Any): Boolean

def addReverseSensor(sensor: (T) ⇒ U)(implicit d: DummyImplicit): ArrayBuffer[(T) ⇒ Iterable[U]]

def addReverseSensor(sensor: (T) ⇒ Iterable[U]): ArrayBuffer[(T) ⇒ Iterable[U]]

def addSensor(sensor: (T) ⇒ U)(implicit d: DummyImplicit): ArrayBuffer[(T) ⇒ Iterable[U]]

def addSensor(sensor: (T) ⇒ Iterable[U]): ArrayBuffer[(T) ⇒ Iterable[U]]

def addSensor(f: (T, U) ⇒ Boolean): ArrayBuffer[(T, U) ⇒ Boolean]

def apply(ts: Iterable[T]): InstanceSet[U]

def apply(t: T): InstanceSet[U]

final def asInstanceOf[T0]: T0

val backward: Link[U, T]

Backward link

def clear(): Unit

def clone(): AnyRef

def deriveIndexWithIds(): Unit

final def eq(arg0: AnyRef): Boolean

def finalize(): Unit

val forward: Link[T, U]

Forward link

def from: Node[T]

final def getClass(): Class[_]

final def isInstanceOf[T0]: Boolean

def links: Seq[(T, U)]

def loadIndexWithIds(in: ExceptionlessInputStream): Unit

val matchers: ArrayBuffer[(T, U) ⇒ Boolean]

val ms: Seq[(T, U) ⇒ Boolean]

Matching functions

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def populateFrom(e: Edge[_, _]): Unit

def populateUsingFrom(t: T, train: Boolean = true): Unit

def populateUsingTo(u: U, train: Boolean = true): Unit

def populateWith(sensor: (T, U) ⇒ Boolean, from: Iterable[T] = forward.from.getAllInstances, to: Iterable[U] = forward.to.getAllInstances): Unit

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

def to: Node[U]

def unary_-: Edge[U, T]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def writeIndexWithIds(out: ExceptionlessOutputStream): Unit

def populateWith(sensor: (T) ⇒ Iterable[U]): Unit

def populateWith(sensor: (T) ⇒ Option[U])(implicit d1: DummyImplicit, d2: DummyImplicit): Unit

def populateWith(sensor: (T) ⇒ U)(implicit d: DummyImplicit): Unit