NodeBase

abstract def addDiPredecessors(edge: EdgeT, add: (NodeT) ⇒ Unit): Unit

abstract def addDiSuccessors(edge: EdgeT, add: (NodeT) ⇒ Unit): Unit

abstract def addNeighbors(edge: EdgeT, add: (NodeT) ⇒ Unit): Unit

abstract def connectionsWith(other: NodeT): Set[EdgeT] with FilterableSet[EdgeT]

All edges connecting this node with other including outgoing and incoming edges.

abstract def degree: Int

The degree of this node.

abstract def diPredecessors: Set[NodeT]

All direct predecessors of this node, also called predecessor set or open in-neighborhood: source nodes of directed incident edges and / or adjacent nodes of undirected incident edges excluding this node.

abstract def diSuccessors: Set[NodeT]

All direct successors of this node, also called successor set or open out-neighborhood: target nodes of directed incident edges and / or adjacent nodes of undirected incident edges excluding this node.

abstract def edges: ExtSet[EdgeT]

All edges at this node - commonly denoted as E(v).

abstract def findIncomingFrom(from: NodeT): Option[EdgeT]

An edge at from having this node as a successor.

abstract def findOutgoingTo(to: NodeT): Option[EdgeT]

An outgoing edge connecting this node with to.

abstract def hasOnlyHooks: Boolean

Checks whether this node has only hooks or no edges at all.

abstract def hasPredecessors: Boolean

Whether this node has any predecessors.

abstract def hasSuccessors: Boolean

Whether this node has any successors.

abstract def inDegree(nodeFilter: (NodeT) ⇒ Boolean, edgeFilter: (EdgeT) ⇒ Boolean = anyEdge, includeHooks: Boolean = false, ignoreMultiEdges: Boolean = true): Int

The incoming degree of this node after applying some filters to the incoming edges and predecessors.

abstract def inDegree: Int

The incoming degree of this node.

abstract def incoming: Set[EdgeT] with FilterableSet[EdgeT]

Incoming edges of this node.

abstract def incomingFrom(from: NodeT): Set[EdgeT] with FilterableSet[EdgeT]

All incoming edges connecting from with this node.

abstract def isContaining[N, E[X] <: EdgeLikeIn[X]](g: GraphBase[N, E]): Boolean

abstract def isDirectPredecessorOf(that: NodeT): Boolean

Whether that is an adjacent (direct successor) to this node.

abstract def isIndependentOf(that: NodeT): Boolean

Whether that is independent of this node meaning that there exists no edge connecting this node with that.

abstract def neighbors: Set[NodeT]

All adjacent nodes (direct successors and predecessors) of this node, also called open neighborhood excluding this node.

abstract def outDegree(nodeFilter: (NodeT) ⇒ Boolean, edgeFilter: (EdgeT) ⇒ Boolean = anyEdge, includeHooks: Boolean = false, ignoreMultiEdges: Boolean = true): Int

The outgoing degree of this node after applying some filters to the outgoing edges and successors.

abstract def outDegree: Int

The outgoing degree of this node.

abstract def outgoing: Set[EdgeT] with FilterableSet[EdgeT]

All edges outgoing from this node.

abstract def outgoingTo(to: NodeT): Set[EdgeT] with FilterableSet[EdgeT]

All outgoing edges connecting this node with to.

abstract def value: N

The outer node as supplied by the user at instantiation time or by adding nodes this graph.

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

def ->[B](y: B): (NodeBase, B)

final def <~(from: NodeT): Set[EdgeT] with FilterableSet[EdgeT]

Synonym for incomingFrom.

final def <~: Set[EdgeT] with FilterableSet[EdgeT]

Synonym for incoming.

final def <~?(from: NodeT): Option[EdgeT]

Synonym for findIncomingFrom.

final def <~|: Set[NodeT]

Synonym for diPredecessors.

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

final def asNodeT[N <: N, E[X] <: EdgeLikeIn[X], G <: GraphBase[N, E] with Singleton](g: G): GraphPredef.InnerNodeParam.asNodeT.G.NodeT

final def asNodeTProjection[N <: N, E[X] <: EdgeLikeIn[X]]: NodeT

def canEqual(that: Any): Boolean

def clone(): AnyRef

def ensuring(cond: (NodeBase) ⇒ Boolean, msg: ⇒ Any): NodeBase

def ensuring(cond: (NodeBase) ⇒ Boolean): NodeBase

def ensuring(cond: Boolean, msg: ⇒ Any): NodeBase

def ensuring(cond: Boolean): NodeBase

final def eq(arg0: AnyRef): Boolean

def equals(other: Any): Boolean

def finalize(): Unit

final def fold[N <: N, E[X] <: EdgeLikeIn[X], G <: GraphBase[N, E] with Singleton, T](g: G)(fa: (GraphPredef.InnerNodeParam.fold.G.NodeT) ⇒ T, fb: (NodeT) ⇒ T): T

def formatted(fmtstr: String): String

final def getClass(): Class[_]

def hashCode(): Int

final def inNeighbors: Set[NodeT]

Synonym for diPredecessors.

def isDefined: Boolean

def isEdge: Boolean

def isIn: Boolean

final def isInstanceOf[T0]: Boolean

final def isIsolated: Boolean

true if this node's degree equals to 0.

final def isLeaf: Boolean

true if this node's degree equals to 1.

def isNode: Boolean

def isOut: Boolean

val n1: NodeBase

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

final def outNeighbors: Set[NodeT]

Synonym for diSuccessors.

def stringPrefix: String

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

final def toNodeT[N <: N, E[X] <: EdgeLikeIn[X], G <: GraphBase[N, E] with Singleton](g: G)(f: (NodeT) ⇒ GraphPredef.InnerNodeParam.toNodeT.G.NodeT): GraphPredef.InnerNodeParam.toNodeT.G.NodeT

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

final def ~: ExtSet[EdgeT]

Synonym for edges.

final def ~>(to: NodeT): Set[EdgeT] with FilterableSet[EdgeT]

Synonym for outgoingTo.

final def ~>: Set[EdgeT] with FilterableSet[EdgeT]

Synonym for outgoing.

final def ~>?(to: NodeT): Option[EdgeT]

Synonym for findOutgoingTo.

final def ~>|: Set[NodeT]

Synonym for diSuccessors.

final def ~|: Set[NodeT]

Synonym for neighbors.

def →[B](y: B): (NodeBase, B)

def isDefined: Boolean

def isEdge: Boolean

def isIn: Boolean

def isNode: Boolean

def isOut: Boolean

val self: Any

val self: Any

def stringPrefix: String

def toString(): String

val value: NodeBase

def ~[N >: N1](n2: N): UnDiEdge[N]

def ~>[N >: N1](n2: N): DiEdge[N]

def x: NodeBase

def x: NodeBase