EdgeOps

Type Members

trait InnerNodeOps extends AnyRef

Value Members

final def !=(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def !=(arg0: Any): Boolean

Definition Classes
Any
final def ##(): Int

Definition Classes
AnyRef → Any
def +(other: String): String

Implicit information
This member is added by an implicit conversion from EdgeOps[N, E, This] to StringAdd performed by method any2stringadd in scala.Predef.
Definition Classes
StringAdd
final def +~%+=[EE[X] <: E[X] with EdgeLikeIn[X] with WLHyperEdgeBound[_, EE], L](node_1: N, node_2: N, nodes: N*)(weight: Long, label: L)(implicit edgeFactory: WLHyperEdgeCompanion[EE], endpointsKind: CollectionKind = Bag): EdgeOps.this.type

Same as addWLEdge(node_1, node_2, nodes)(weight, label) except for the returned result.
Same as addWLEdge(node_1, node_2, nodes)(weight, label) except for the returned result.
returns
This mutable graph containing the hyperedge that has been created or found. to be created equals to an already existing hyperedge.

Annotations
@inline()
final def +~%+=[EE[X] <: E[X] with EdgeLikeIn[X] with WLEdgeBound[_, EE], L](node_1: N, node_2: N)(weight: Long, label: L)(implicit edgeFactory: WLEdgeCompanion[EE]): EdgeOps.this.type

Same as addWLEdge(node_1, node_2)(weight, label) except for the returned result.
Same as addWLEdge(node_1, node_2)(weight, label) except for the returned result.
returns
This mutable graph containing the edge that has been created or found.

Annotations
@inline()
final def +~%=[EE[X] <: E[X] with EdgeLikeIn[X] with WHyperEdgeBound[_, EE]](node_1: N, node_2: N, nodes: N*)(weight: Long)(implicit edgeFactory: WHyperEdgeCompanion[EE], endpointsKind: CollectionKind = Bag): EdgeOps.this.type

Same as addWEdge(node_1, node_2, nodes)(weight) except for the returned result.
Same as addWEdge(node_1, node_2, nodes)(weight) except for the returned result.
returns
This mutable graph containing the hyperedge that has been created or found. to be created equals to an already existing hyperedge.

Annotations
@inline()
final def +~%=[EE[X] <: E[X] with EdgeLikeIn[X] with WEdgeBound[_, EE]](node_1: N, node_2: N)(weight: Long)(implicit edgeFactory: WEdgeCompanion[EE]): EdgeOps.this.type

Same as addWEdge(node_1, node_2)(weight) except for the returned result.
Same as addWEdge(node_1, node_2)(weight) except for the returned result.
returns
This mutable graph containing the edge that has been created or found.

Annotations
@inline()
final def +~+=[EE[X] <: E[X] with EdgeLikeIn[X] with LHyperEdgeBound[_, EE], L](node_1: N, node_2: N, nodes: N*)(label: L)(implicit edgeFactory: LHyperEdgeCompanion[EE]): EdgeOps.this.type

Same as addLEdge(node_1, node_2, nodes)(label) except for the returned result.
Same as addLEdge(node_1, node_2, nodes)(label) except for the returned result.
returns
This mutable graph containing the hyperedge that has been created or found. to be created equals to an already existing hyperedge.

Annotations
@inline()
final def +~+=[EE[X] <: E[X] with EdgeLikeIn[X] with LEdgeBound[_, EE], L](node_1: N, node_2: N)(label: L)(implicit edgeFactory: LEdgeCompanion[EE]): EdgeOps.this.type

Same as addLEdge(node_1, node_2)(label) except for the returned result.
Same as addLEdge(node_1, node_2)(label) except for the returned result.
returns
This mutable graph containing the edge that has been created or found.

Annotations
@inline()
final def +~=(node_1: N, node_2: N, nodes: N*)(implicit edgeFactory: HyperEdgeCompanion[E], endpointsKind: CollectionKind = Bag): EdgeOps.this.type

Same as addEdge(node_1, node_2, nodes) except for the returned result.
Same as addEdge(node_1, node_2, nodes) except for the returned result.
returns
This mutable graph containing the hyperedge that has been created or found. to be created equals to an already existing hyperedge.

Annotations
@inline()
final def +~=(node_1: N, node_2: N)(implicit edgeFactory: EdgeCompanion[E]): EdgeOps.this.type

Same as addEdge(node_1, node_2) except for the returned result.
Same as addEdge(node_1, node_2) except for the returned result.
returns
This mutable graph containing the edge that has been created or found.

Annotations
@inline()
def ->[B](y: B): (EdgeOps[N, E, This], B)

Implicit information
This member is added by an implicit conversion from EdgeOps[N, E, This] to ArrowAssoc[EdgeOps[N, E, This]] performed by method any2ArrowAssoc in scala.Predef.
Definition Classes
ArrowAssoc
Annotations
@inline()
final def ==(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def ==(arg0: Any): Boolean

Definition Classes
Any
def addAndGetEdge(node_1: N, node_2: N, nodes: N*)(implicit edgeFactory: HyperEdgeCompanion[E], endpointsKind: CollectionKind = Bag): GraphLike.EdgeT

Same as addEdge(node_1, node_2, nodes) except for the returned result.
Same as addEdge(node_1, node_2, nodes) except for the returned result.
returns
The new hyperedge or the corresponding contained hyperedge if the hyperedge to be created equals to an already existing hyperedge.
final def addAndGetEdge(node_1: N, node_2: N)(implicit edgeFactory: EdgeCompanion[E]): GraphLike.EdgeT

Same as addEdge(node_1, node_2) except for the returned result.
Same as addEdge(node_1, node_2) except for the returned result.
returns
The new edge or the corresponding contained edge if the edge to be created equals to an already existing edge.

Annotations
@inline()
def addAndGetLEdge[EE[X] <: E[X] with EdgeLikeIn[X] with LHyperEdgeBound[_, EE], L](node_1: N, node_2: N, nodes: N*)(label: L)(implicit edgeFactory: LHyperEdgeCompanion[EE]): GraphLike.EdgeT

Same as addLEdge(node_1, node_2, nodes)(label) except for the returned result.
Same as addLEdge(node_1, node_2, nodes)(label) except for the returned result.
returns
The new hyperedge or the corresponding contained hyperedge if the hyperedge to be created equals to an already existing hyperedge.
final def addAndGetLEdge[EE[X] <: E[X] with EdgeLikeIn[X] with LEdgeBound[_, EE], L](node_1: N, node_2: N)(label: L)(implicit edgeFactory: LEdgeCompanion[EE]): GraphLike.EdgeT

Same as addLEdge(node_1, node_2)(label) except for the returned result.
Same as addLEdge(node_1, node_2)(label) except for the returned result.
returns
The new edge or the corresponding contained edge if the edge to be created equals to an already existing edge.

Annotations
@inline()
def addAndGetWEdge[EE[X] <: E[X] with EdgeLikeIn[X] with WHyperEdgeBound[_, EE]](node_1: N, node_2: N, nodes: N*)(weight: Long)(implicit edgeFactory: WHyperEdgeCompanion[EE], endpointsKind: CollectionKind = Bag): GraphLike.EdgeT

Same as addWEdge(node_1, node_2, nodes)(weight) except for the returned result.
Same as addWEdge(node_1, node_2, nodes)(weight) except for the returned result.
returns
The new hyperedge or the corresponding contained hyperedge if the hyperedge to be created equals to an already existing hyperedge.
final def addAndGetWEdge[EE[X] <: E[X] with EdgeLikeIn[X] with WEdgeBound[_, EE]](node_1: N, node_2: N)(weight: Long)(implicit edgeFactory: WEdgeCompanion[EE]): GraphLike.EdgeT

Same as addWEdge(node_1, node_2)(weight) except for the returned result.
Same as addWEdge(node_1, node_2)(weight) except for the returned result.
returns
The new edge or the corresponding contained edge if the edge to be created equals to an already existing edge.

Annotations
@inline()
def addAndGetWLEdge[EE[X] <: E[X] with EdgeLikeIn[X] with WLHyperEdgeBound[_, EE], L](node_1: N, node_2: N, nodes: N*)(weight: Long, label: L)(implicit edgeFactory: WLHyperEdgeCompanion[EE], endpointsKind: CollectionKind = Bag): GraphLike.EdgeT

Same as addWLEdge(node_1, node_2, nodes)(weight, label) except for the returned result.
Same as addWLEdge(node_1, node_2, nodes)(weight, label) except for the returned result.
returns
The new hyperedge or the corresponding contained hyperedge if the hyperedge to be created equals to an already existing hyperedge.
final def addAndGetWLEdge[EE[X] <: E[X] with EdgeLikeIn[X] with WLEdgeBound[_, EE], L](node_1: N, node_2: N)(weight: Long, label: L)(implicit edgeFactory: WLEdgeCompanion[EE]): GraphLike.EdgeT

Same as addWLEdge(node_1, node_2)(weight, label) except for the returned result.
Same as addWLEdge(node_1, node_2)(weight, label) except for the returned result.
returns
The new edge or the corresponding contained edge if the edge to be created equals to an already existing edge.

Annotations
@inline()
final def addEdge(node_1: N, node_2: N, nodes: N*)(implicit edgeFactory: HyperEdgeCompanion[E], endpointsKind: CollectionKind = Bag): Boolean

Creates a new inner hyperedge between node_1, node_2 and nodes using edgeFactory and adds it to the edge set of this graph.
Creates a new inner hyperedge between node_1, node_2 and nodes using edgeFactory and adds it to the edge set of this graph. Node arguments not yet contained in this graph will be added to the node set.
node_1
The first outer node to be incident with the edge to be created. In case of a directed edge, this becomes the source.
node_2
The second outer node to be incident with the edge to be created. In case of a directed edge, this becomes the target.
nodes
The third and possibly more inner or outer nodes to be incident with the hyperedge to be created. In case of a directed edge, these become targets.
edgeFactory
An edge companion who's from is to serve as the edge factory.
returns
true if a new hyperedge has been created. false if no new hyperedge could be created because there exists a corresponding equaling hyperedge.

Annotations
@inline()
final def addEdge(node_1: N, node_2: N)(implicit edgeFactory: EdgeCompanion[E]): Boolean

Creates a new inner edge between node_1 and node_2 using edgeFactory and adds it to the edge set of this graph.
Creates a new inner edge between node_1 and node_2 using edgeFactory and adds it to the edge set of this graph. Node arguments not yet contained in this graph will be added to the node set.
node_1
The first outer node to be incident with the edge to be created. In case of a directed edge, this becomes the source.
node_2
The second outer node to be incident with the edge to be created. In case of a directed edge, this becomes the target.
edgeFactory
An edge companion who's from is to serve as the edge factory.
returns
true if a new edge has been created. false if no new edge could be created because there exists a corresponding equaling edge.

Annotations
@inline()
final def addLEdge[EE[X] <: E[X] with EdgeLikeIn[X] with LHyperEdgeBound[_, EE], L](node_1: N, node_2: N, nodes: N*)(label: L)(implicit edgeFactory: LHyperEdgeCompanion[EE]): Boolean

Creates a new weighted and labeled inner hyperedge between node_1, node_2 and nodes using edgeFactory and adds it to the edge set of this graph.
Creates a new weighted and labeled inner hyperedge between node_1, node_2 and nodes using edgeFactory and adds it to the edge set of this graph. Node arguments not yet contained in this graph will be added to the node set.
node_1
The first outer node to be incident with the edge to be created. In case of a directed edge, this becomes the source.
node_2
The second outer node to be incident with the edge to be created. In case of a directed edge, this becomes the target.
nodes
The third and possibly more inner or outer nodes to be incident with the hyperedge to be created. In case of a directed edge, these become targets.
label
The value the labeled edge to be created should have as its label.
edgeFactory
An edge companion who's from is to serve as the edge factory.
returns
true if a new hyperedge has been created. false if no new hyperedge could be created because there exists a corresponding equaling hyperedge.

Annotations
@inline()
final def addLEdge[EE[X] <: E[X] with EdgeLikeIn[X] with LEdgeBound[_, EE], L](node_1: N, node_2: N)(label: L)(implicit edgeFactory: LEdgeCompanion[EE]): Boolean

Creates a new labeled inner edge between node_1 and node_2 using edgeFactory and adds it to the edge set of this graph.
Creates a new labeled inner edge between node_1 and node_2 using edgeFactory and adds it to the edge set of this graph. Node arguments not yet contained in this graph will be added to the node set.
node_1
The first outer node to be incident with the edge to be created. In case of a directed edge, this becomes the source.
node_2
The second outer node to be incident with the edge to be created. In case of a directed edge, this becomes the target.
label
The value the labeled edge to be created should have as its label.
edgeFactory
An edge companion who's from is to serve as the edge factory.
returns
true if a new edge has been created. false if no new edge could be created because there exists a corresponding equaling edge.

Annotations
@inline()
final def addWEdge[EE[X] <: E[X] with EdgeLikeIn[X] with WHyperEdgeBound[_, EE]](node_1: N, node_2: N, nodes: N*)(weight: Long)(implicit edgeFactory: WHyperEdgeCompanion[EE], endpointsKind: CollectionKind = Bag): Boolean

Creates a new weighted inner hyperedge between node_1, node_2 and nodes using edgeFactory and adds it to the edge set of this graph.
Creates a new weighted inner hyperedge between node_1, node_2 and nodes using edgeFactory and adds it to the edge set of this graph. Node arguments not yet contained in this graph will be added to the node set.
node_1
The first outer node to be incident with the edge to be created. In case of a directed edge, this becomes the source.
node_2
The second outer node to be incident with the edge to be created. In case of a directed edge, this becomes the target.
nodes
The third and possibly more inner or outer nodes to be incident with the hyperedge to be created. In case of a directed edge, these become targets.
weight
The number the weighted edge to be created should have as its weight.
edgeFactory
An edge companion who's from is to serve as the edge factory.
returns
true if a new hyperedge has been created. false if no new hyperedge could be created because there exists a corresponding equaling hyperedge.

Annotations
@inline()
final def addWEdge[EE[X] <: E[X] with EdgeLikeIn[X] with WEdgeBound[_, EE]](node_1: N, node_2: N)(weight: Long)(implicit edgeFactory: WEdgeCompanion[EE]): Boolean

Creates a new weighted inner edge between node_1 and node_2 using edgeFactory and adds it to the edge set of this graph.
Creates a new weighted inner edge between node_1 and node_2 using edgeFactory and adds it to the edge set of this graph. Node arguments not yet contained in this graph will be added to the node set.
node_1
The first outer node to be incident with the edge to be created. In case of a directed edge, this becomes the source.
node_2
The second outer node to be incident with the edge to be created. In case of a directed edge, this becomes the target.
weight
The number the weighted edge to be created should have as its weight.
edgeFactory
An edge companion who's from is to serve as the edge factory.
returns
true if a new edge has been created. false if no new edge could be created because there exists a corresponding equaling edge.

Annotations
@inline()
final def addWLEdge[EE[X] <: E[X] with EdgeLikeIn[X] with WLHyperEdgeBound[_, EE], L](node_1: N, node_2: N, nodes: N*)(weight: Long, label: L)(implicit edgeFactory: WLHyperEdgeCompanion[EE], endpointsKind: CollectionKind = Bag): Boolean

Creates a new weighted and labeled inner hyperedge between node_1, node_2 and nodes using edgeFactory and adds it to the edge set of this graph.
Creates a new weighted and labeled inner hyperedge between node_1, node_2 and nodes using edgeFactory and adds it to the edge set of this graph. Node arguments not yet contained in this graph will be added to the node set.
node_1
The first outer node to be incident with the edge to be created. In case of a directed edge, this becomes the source.
node_2
The second outer node to be incident with the edge to be created. In case of a directed edge, this becomes the target.
nodes
The third and possibly more inner or outer nodes to be incident with the hyperedge to be created. In case of a directed edge, these become targets.
weight
The number the weighted edge to be created should have as its weight.
label
The value the labeled edge to be created should have as its label.
edgeFactory
An edge companion who's from is to serve as the edge factory.
returns
true if a new hyperedge has been created. false if no new hyperedge could be created because there exists a corresponding equaling hyperedge.

Annotations
@inline()
final def addWLEdge[EE[X] <: E[X] with EdgeLikeIn[X] with WLEdgeBound[_, EE], L](node_1: N, node_2: N)(weight: Long, label: L)(implicit edgeFactory: WLEdgeCompanion[EE]): Boolean

Creates a new weighted and labeled inner edge between node_1 and node_2 using edgeFactory and adds it to the edge set of this graph.
Creates a new weighted and labeled inner edge between node_1 and node_2 using edgeFactory and adds it to the edge set of this graph. Node arguments not yet contained in this graph will be added to the node set.
node_1
The first outer node to be incident with the edge to be created. In case of a directed edge, this becomes the source.
node_2
The second outer node to be incident with the edge to be created. In case of a directed edge, this becomes the target.
weight
The number the weighted edge to be created should have as its weight.
label
The value the labeled edge to be created should have as its label.
edgeFactory
An edge companion who's from is to serve as the edge factory.
returns
true if a new edge has been created. false if no new edge could be created because there exists a corresponding equaling edge.

Annotations
@inline()
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def ensuring(cond: (EdgeOps[N, E, This]) ⇒ Boolean, msg: ⇒ Any): EdgeOps[N, E, This]

Implicit information
This member is added by an implicit conversion from EdgeOps[N, E, This] to Ensuring[EdgeOps[N, E, This]] performed by method any2Ensuring in scala.Predef.
Definition Classes
Ensuring
def ensuring(cond: (EdgeOps[N, E, This]) ⇒ Boolean): EdgeOps[N, E, This]

Implicit information
This member is added by an implicit conversion from EdgeOps[N, E, This] to Ensuring[EdgeOps[N, E, This]] performed by method any2Ensuring in scala.Predef.
Definition Classes
Ensuring
def ensuring(cond: Boolean, msg: ⇒ Any): EdgeOps[N, E, This]

Implicit information
This member is added by an implicit conversion from EdgeOps[N, E, This] to Ensuring[EdgeOps[N, E, This]] performed by method any2Ensuring in scala.Predef.
Definition Classes
Ensuring
def ensuring(cond: Boolean): EdgeOps[N, E, This]

Implicit information
This member is added by an implicit conversion from EdgeOps[N, E, This] to Ensuring[EdgeOps[N, E, This]] performed by method any2Ensuring in scala.Predef.
Definition Classes
Ensuring
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def formatted(fmtstr: String): String

Implicit information
This member is added by an implicit conversion from EdgeOps[N, E, This] to StringFormat performed by method any2stringfmt in scala.Predef.
Definition Classes
StringFormat
Annotations
@inline()
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def nodesToCEdgeCont[EE[X] <: E[X] with EdgeLikeIn[X] with CHyperEdgeBound[_, EE]](factory: CHyperEdgeCompanion[EE], attrib: Product, node_1: N, node_2: N, nodes: N*)(implicit kind: CollectionKind): E[NodeT]

Creates a new custom inner hyperedge without modifying the node or edge set .
Creates a new custom inner hyperedge without modifying the node or edge set .

Attributes
protected[scalax.collection]
def nodesToCEdgeCont[EE[X] <: E[X] with EdgeLikeIn[X] with CEdgeBound[_, EE]](factory: CEdgeCompanion[EE], attrib: Product, node_1: N, node_2: N): E[NodeT]

Creates a new custom inner edge without modifying the node or edge set .
Creates a new custom inner edge without modifying the node or edge set .

Attributes
protected[scalax.collection]
final def nodesToEdge(edgeFactory: HyperEdgeCompanion[E], node_1: N, node_2: N, nodes: N*)(implicit endpointsKind: CollectionKind): GraphLike.EdgeT

Attributes
protected
Annotations
@inline()
final def nodesToEdge(edgeFactory: EdgeCompanion[E], node_1: N, node_2: N): GraphLike.EdgeT

Attributes
protected
Annotations
@inline()
def nodesToEdgeCont(factory: EdgeCompanion[E], node_1: N, node_2: N): E[NodeT]

Creates a new simple inner edge without modifying the node or edge set .
Creates a new simple inner edge without modifying the node or edge set .

Attributes
protected[scalax.collection]
def nodesToEdgeCont(factory: HyperEdgeCompanion[E], node_1: N, node_2: N, nodes: N*)(implicit kind: CollectionKind): E[NodeT]

Creates a new simple inner hyperedge without modifying the node or edge set .
Creates a new simple inner hyperedge without modifying the node or edge set .

Attributes
protected[scalax.collection]
final def nodesToLEdge[EE[X] <: E[X] with EdgeLikeIn[X] with LHyperEdgeBound[_, EE], L](edgeFactory: LHyperEdgeCompanion[EE], label: L, node_1: N, node_2: N, nodes: N*): GraphLike.EdgeT

Attributes
protected
Annotations
@inline()
final def nodesToLEdge[EE[X] <: E[X] with EdgeLikeIn[X] with LEdgeBound[_, EE], L](edgeFactory: LEdgeCompanion[EE], label: L, node_1: N, node_2: N): GraphLike.EdgeT

Attributes
protected
Annotations
@inline()
def nodesToLEdgeCont[EE[X] <: E[X] with EdgeLikeIn[X] with LEdgeBound[_, EE], L](factory: LEdgeCompanion[EE], label: L, node_1: N, node_2: N): E[NodeT]

Creates a new labeled inner edge without modifying the node or edge set .
Creates a new labeled inner edge without modifying the node or edge set .

Attributes
protected[scalax.collection]
def nodesToLEdgeCont[EE[X] <: E[X] with EdgeLikeIn[X] with LHyperEdgeBound[_, EE], L](factory: LHyperEdgeCompanion[EE], label: L, node_1: N, node_2: N, nodes: N*)(implicit kind: CollectionKind = Bag): E[NodeT]

Creates a new labeled inner hyperedge without modifying the node or edge set .
Creates a new labeled inner hyperedge without modifying the node or edge set .

Attributes
protected[scalax.collection]
final def nodesToWEdge[EE[X] <: E[X] with EdgeLikeIn[X] with WHyperEdgeBound[_, EE]](edgeFactory: WHyperEdgeCompanion[EE], weight: Long, node_1: N, node_2: N, nodes: N*)(implicit kind: CollectionKind): GraphLike.EdgeT

Attributes
protected
Annotations
@inline()
final def nodesToWEdge[EE[X] <: E[X] with EdgeLikeIn[X] with WEdgeBound[_, EE]](edgeFactory: WEdgeCompanion[EE], weight: Long, node_1: N, node_2: N): GraphLike.EdgeT

Attributes
protected
Annotations
@inline()
def nodesToWEdgeCont[EE[X] <: E[X] with EdgeLikeIn[X] with WEdgeBound[_, EE]](factory: WEdgeCompanion[EE], weight: Long, node_1: N, node_2: N): E[NodeT]

Creates a new weighted inner edge without modifying the node or edge set .
Creates a new weighted inner edge without modifying the node or edge set .

Attributes
protected[scalax.collection]
def nodesToWEdgeCont[EE[X] <: E[X] with EdgeLikeIn[X] with WHyperEdgeBound[_, EE]](factory: WHyperEdgeCompanion[EE], weight: Long, node_1: N, node_2: N, nodes: N*)(implicit kind: CollectionKind): E[NodeT]

Creates a new weighted inner hyperedge without modifying the node or edge set .
Creates a new weighted inner hyperedge without modifying the node or edge set .

Attributes
protected[scalax.collection]
final def nodesToWLEdge[EE[X] <: E[X] with EdgeLikeIn[X] with WLHyperEdgeBound[_, EE], L](edgeFactory: WLHyperEdgeCompanion[EE], weight: Long, label: L, node_1: N, node_2: N, nodes: N*)(implicit kind: CollectionKind): GraphLike.EdgeT

Attributes
protected
Annotations
@inline()
final def nodesToWLEdge[EE[X] <: E[X] with EdgeLikeIn[X] with WLEdgeBound[_, EE], L](edgeFactory: WLEdgeCompanion[EE], weight: Long, label: L, node_1: N, node_2: N): GraphLike.EdgeT

Attributes
protected
Annotations
@inline()
def nodesToWLEdgeCont[EE[X] <: E[X] with EdgeLikeIn[X] with WLEdgeBound[_, EE], L](factory: WLEdgeCompanion[EE], weight: Long, label: L, node_1: N, node_2: N): E[NodeT]

Creates a new weighted and labeled inner edge without modifying the node or edge set .
Creates a new weighted and labeled inner edge without modifying the node or edge set .

Attributes
protected[scalax.collection]
def nodesToWLEdgeCont[EE[X] <: E[X] with EdgeLikeIn[X] with WLHyperEdgeBound[_, EE], L](factory: WLHyperEdgeCompanion[EE], weight: Long, label: L, node_1: N, node_2: N, nodes: N*)(implicit kind: CollectionKind): E[NodeT]

Creates a new weighted and labeled inner hyperedge without modifying the node or edge set .
Creates a new weighted and labeled inner hyperedge without modifying the node or edge set .

Attributes
protected[scalax.collection]
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
def →[B](y: B): (EdgeOps[N, E, This], B)

Implicit information
This member is added by an implicit conversion from EdgeOps[N, E, This] to ArrowAssoc[EdgeOps[N, E, This]] performed by method any2ArrowAssoc in scala.Predef.
Definition Classes
ArrowAssoc

Shadowed Implicit Value Members

val self: Any
Implicit information
This member is added by an implicit conversion from EdgeOps[N, E, This] to StringAdd performed by method any2stringadd in scala.Predef.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(edgeOps: StringAdd).self
Definition Classes
StringAdd
val self: Any
Implicit information
This member is added by an implicit conversion from EdgeOps[N, E, This] to StringFormat performed by method any2stringfmt in scala.Predef.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(edgeOps: StringFormat).self
Definition Classes
StringFormat

Deprecated Value Members

def x: EdgeOps[N, E, This]
Implicit information
This member is added by an implicit conversion from EdgeOps[N, E, This] to ArrowAssoc[EdgeOps[N, E, This]] performed by method any2ArrowAssoc in scala.Predef.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(edgeOps: ArrowAssoc[EdgeOps[N, E, This]]).x
Definition Classes
ArrowAssoc
Annotations
@deprecated
Deprecated
(Since version 2.10.0) Use leftOfArrow instead
def x: EdgeOps[N, E, This]
Implicit information
This member is added by an implicit conversion from EdgeOps[N, E, This] to Ensuring[EdgeOps[N, E, This]] performed by method any2Ensuring in scala.Predef.
Shadowing
This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:
(edgeOps: Ensuring[EdgeOps[N, E, This]]).x
Definition Classes
Ensuring
Annotations
@deprecated
Deprecated
(Since version 2.10.0) Use resultOfEnsuring instead

trait EdgeOps[N, E[X] <: EdgeLikeIn[X], +This[X, Y[X] <: EdgeLikeIn[X]] <: GraphLike[X, Y[X], This] with Graph[X, Y[X]]] extends AnyRef

Type Members

trait InnerNodeOps extends AnyRef

Value Members

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

final def +~%+=[EE[X] <: E[X] with EdgeLikeIn[X] with WLHyperEdgeBound[_, EE], L](node_1: N, node_2: N, nodes: N*)(weight: Long, label: L)(implicit edgeFactory: WLHyperEdgeCompanion[EE], endpointsKind: CollectionKind = Bag): EdgeOps.this.type

final def +~%+=[EE[X] <: E[X] with EdgeLikeIn[X] with WLEdgeBound[_, EE], L](node_1: N, node_2: N)(weight: Long, label: L)(implicit edgeFactory: WLEdgeCompanion[EE]): EdgeOps.this.type

final def +~%=[EE[X] <: E[X] with EdgeLikeIn[X] with WHyperEdgeBound[_, EE]](node_1: N, node_2: N, nodes: N*)(weight: Long)(implicit edgeFactory: WHyperEdgeCompanion[EE], endpointsKind: CollectionKind = Bag): EdgeOps.this.type

final def +~%=[EE[X] <: E[X] with EdgeLikeIn[X] with WEdgeBound[_, EE]](node_1: N, node_2: N)(weight: Long)(implicit edgeFactory: WEdgeCompanion[EE]): EdgeOps.this.type

final def +~+=[EE[X] <: E[X] with EdgeLikeIn[X] with LHyperEdgeBound[_, EE], L](node_1: N, node_2: N, nodes: N*)(label: L)(implicit edgeFactory: LHyperEdgeCompanion[EE]): EdgeOps.this.type

final def +~+=[EE[X] <: E[X] with EdgeLikeIn[X] with LEdgeBound[_, EE], L](node_1: N, node_2: N)(label: L)(implicit edgeFactory: LEdgeCompanion[EE]): EdgeOps.this.type

final def +~=(node_1: N, node_2: N, nodes: N*)(implicit edgeFactory: HyperEdgeCompanion[E], endpointsKind: CollectionKind = Bag): EdgeOps.this.type

final def +~=(node_1: N, node_2: N)(implicit edgeFactory: EdgeCompanion[E]): EdgeOps.this.type

def ->[B](y: B): (EdgeOps[N, E, This], B)

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def addAndGetEdge(node_1: N, node_2: N, nodes: N*)(implicit edgeFactory: HyperEdgeCompanion[E], endpointsKind: CollectionKind = Bag): GraphLike.EdgeT

final def addAndGetEdge(node_1: N, node_2: N)(implicit edgeFactory: EdgeCompanion[E]): GraphLike.EdgeT

def addAndGetLEdge[EE[X] <: E[X] with EdgeLikeIn[X] with LHyperEdgeBound[_, EE], L](node_1: N, node_2: N, nodes: N*)(label: L)(implicit edgeFactory: LHyperEdgeCompanion[EE]): GraphLike.EdgeT

final def addAndGetLEdge[EE[X] <: E[X] with EdgeLikeIn[X] with LEdgeBound[_, EE], L](node_1: N, node_2: N)(label: L)(implicit edgeFactory: LEdgeCompanion[EE]): GraphLike.EdgeT

def addAndGetWEdge[EE[X] <: E[X] with EdgeLikeIn[X] with WHyperEdgeBound[_, EE]](node_1: N, node_2: N, nodes: N*)(weight: Long)(implicit edgeFactory: WHyperEdgeCompanion[EE], endpointsKind: CollectionKind = Bag): GraphLike.EdgeT

final def addAndGetWEdge[EE[X] <: E[X] with EdgeLikeIn[X] with WEdgeBound[_, EE]](node_1: N, node_2: N)(weight: Long)(implicit edgeFactory: WEdgeCompanion[EE]): GraphLike.EdgeT

def addAndGetWLEdge[EE[X] <: E[X] with EdgeLikeIn[X] with WLHyperEdgeBound[_, EE], L](node_1: N, node_2: N, nodes: N*)(weight: Long, label: L)(implicit edgeFactory: WLHyperEdgeCompanion[EE], endpointsKind: CollectionKind = Bag): GraphLike.EdgeT

final def addAndGetWLEdge[EE[X] <: E[X] with EdgeLikeIn[X] with WLEdgeBound[_, EE], L](node_1: N, node_2: N)(weight: Long, label: L)(implicit edgeFactory: WLEdgeCompanion[EE]): GraphLike.EdgeT

final def addEdge(node_1: N, node_2: N, nodes: N*)(implicit edgeFactory: HyperEdgeCompanion[E], endpointsKind: CollectionKind = Bag): Boolean

final def addEdge(node_1: N, node_2: N)(implicit edgeFactory: EdgeCompanion[E]): Boolean

final def addLEdge[EE[X] <: E[X] with EdgeLikeIn[X] with LHyperEdgeBound[_, EE], L](node_1: N, node_2: N, nodes: N*)(label: L)(implicit edgeFactory: LHyperEdgeCompanion[EE]): Boolean

final def addLEdge[EE[X] <: E[X] with EdgeLikeIn[X] with LEdgeBound[_, EE], L](node_1: N, node_2: N)(label: L)(implicit edgeFactory: LEdgeCompanion[EE]): Boolean

final def addWEdge[EE[X] <: E[X] with EdgeLikeIn[X] with WHyperEdgeBound[_, EE]](node_1: N, node_2: N, nodes: N*)(weight: Long)(implicit edgeFactory: WHyperEdgeCompanion[EE], endpointsKind: CollectionKind = Bag): Boolean

final def addWEdge[EE[X] <: E[X] with EdgeLikeIn[X] with WEdgeBound[_, EE]](node_1: N, node_2: N)(weight: Long)(implicit edgeFactory: WEdgeCompanion[EE]): Boolean

final def addWLEdge[EE[X] <: E[X] with EdgeLikeIn[X] with WLHyperEdgeBound[_, EE], L](node_1: N, node_2: N, nodes: N*)(weight: Long, label: L)(implicit edgeFactory: WLHyperEdgeCompanion[EE], endpointsKind: CollectionKind = Bag): Boolean

final def addWLEdge[EE[X] <: E[X] with EdgeLikeIn[X] with WLEdgeBound[_, EE], L](node_1: N, node_2: N)(weight: Long, label: L)(implicit edgeFactory: WLEdgeCompanion[EE]): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def ensuring(cond: (EdgeOps[N, E, This]) ⇒ Boolean, msg: ⇒ Any): EdgeOps[N, E, This]

def ensuring(cond: (EdgeOps[N, E, This]) ⇒ Boolean): EdgeOps[N, E, This]

def ensuring(cond: Boolean, msg: ⇒ Any): EdgeOps[N, E, This]

def ensuring(cond: Boolean): EdgeOps[N, E, This]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def formatted(fmtstr: String): String

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

def nodesToCEdgeCont[EE[X] <: E[X] with EdgeLikeIn[X] with CHyperEdgeBound[_, EE]](factory: CHyperEdgeCompanion[EE], attrib: Product, node_1: N, node_2: N, nodes: N*)(implicit kind: CollectionKind): E[NodeT]

def nodesToCEdgeCont[EE[X] <: E[X] with EdgeLikeIn[X] with CEdgeBound[_, EE]](factory: CEdgeCompanion[EE], attrib: Product, node_1: N, node_2: N): E[NodeT]

final def nodesToEdge(edgeFactory: HyperEdgeCompanion[E], node_1: N, node_2: N, nodes: N*)(implicit endpointsKind: CollectionKind): GraphLike.EdgeT

final def nodesToEdge(edgeFactory: EdgeCompanion[E], node_1: N, node_2: N): GraphLike.EdgeT

def nodesToEdgeCont(factory: EdgeCompanion[E], node_1: N, node_2: N): E[NodeT]

def nodesToEdgeCont(factory: HyperEdgeCompanion[E], node_1: N, node_2: N, nodes: N*)(implicit kind: CollectionKind): E[NodeT]

final def nodesToLEdge[EE[X] <: E[X] with EdgeLikeIn[X] with LHyperEdgeBound[_, EE], L](edgeFactory: LHyperEdgeCompanion[EE], label: L, node_1: N, node_2: N, nodes: N*): GraphLike.EdgeT

final def nodesToLEdge[EE[X] <: E[X] with EdgeLikeIn[X] with LEdgeBound[_, EE], L](edgeFactory: LEdgeCompanion[EE], label: L, node_1: N, node_2: N): GraphLike.EdgeT

def nodesToLEdgeCont[EE[X] <: E[X] with EdgeLikeIn[X] with LEdgeBound[_, EE], L](factory: LEdgeCompanion[EE], label: L, node_1: N, node_2: N): E[NodeT]

def nodesToLEdgeCont[EE[X] <: E[X] with EdgeLikeIn[X] with LHyperEdgeBound[_, EE], L](factory: LHyperEdgeCompanion[EE], label: L, node_1: N, node_2: N, nodes: N*)(implicit kind: CollectionKind = Bag): E[NodeT]

final def nodesToWEdge[EE[X] <: E[X] with EdgeLikeIn[X] with WHyperEdgeBound[_, EE]](edgeFactory: WHyperEdgeCompanion[EE], weight: Long, node_1: N, node_2: N, nodes: N*)(implicit kind: CollectionKind): GraphLike.EdgeT

final def nodesToWEdge[EE[X] <: E[X] with EdgeLikeIn[X] with WEdgeBound[_, EE]](edgeFactory: WEdgeCompanion[EE], weight: Long, node_1: N, node_2: N): GraphLike.EdgeT

def nodesToWEdgeCont[EE[X] <: E[X] with EdgeLikeIn[X] with WEdgeBound[_, EE]](factory: WEdgeCompanion[EE], weight: Long, node_1: N, node_2: N): E[NodeT]

def nodesToWEdgeCont[EE[X] <: E[X] with EdgeLikeIn[X] with WHyperEdgeBound[_, EE]](factory: WHyperEdgeCompanion[EE], weight: Long, node_1: N, node_2: N, nodes: N*)(implicit kind: CollectionKind): E[NodeT]

final def nodesToWLEdge[EE[X] <: E[X] with EdgeLikeIn[X] with WLHyperEdgeBound[_, EE], L](edgeFactory: WLHyperEdgeCompanion[EE], weight: Long, label: L, node_1: N, node_2: N, nodes: N*)(implicit kind: CollectionKind): GraphLike.EdgeT

final def nodesToWLEdge[EE[X] <: E[X] with EdgeLikeIn[X] with WLEdgeBound[_, EE], L](edgeFactory: WLEdgeCompanion[EE], weight: Long, label: L, node_1: N, node_2: N): GraphLike.EdgeT

def nodesToWLEdgeCont[EE[X] <: E[X] with EdgeLikeIn[X] with WLEdgeBound[_, EE], L](factory: WLEdgeCompanion[EE], weight: Long, label: L, node_1: N, node_2: N): E[NodeT]

def nodesToWLEdgeCont[EE[X] <: E[X] with EdgeLikeIn[X] with WLHyperEdgeBound[_, EE], L](factory: WLHyperEdgeCompanion[EE], weight: Long, label: L, node_1: N, node_2: N, nodes: N*)(implicit kind: CollectionKind): E[NodeT]

final def notify(): Unit

final def notifyAll(): Unit

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

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def →[B](y: B): (EdgeOps[N, E, This], B)

Shadowed Implicit Value Members

val self: Any

val self: Any

Deprecated Value Members