SymmetricEdge

final def !=(arg0: Any): Boolean

final def ##(): Int

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

final def ==(arg0: Any): Boolean

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

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

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

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

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

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

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

final def asInstanceOf[T0]: T0

def backward: Link[T, T]

def clear(): Unit

def clone(): AnyRef

def deriveIndexWithIds(): Unit

final def eq(arg0: AnyRef): Boolean

def finalize(): Unit

def forward: Link[T, T]

def from: Node[T]

final def getClass(): Class[_]

final def isInstanceOf[T0]: Boolean

val link: Link[T, T]

Link

def links: Seq[(T, T)]

def loadIndexWithIds(in: ExceptionlessInputStream): Unit

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

val ms: Seq[(T, T) ⇒ 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: T, train: Boolean = true): Unit

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

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

def to: Node[T]

def unary_-: SymmetricEdge[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[T]): Unit

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

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