GraphLike

trait GraphLike[N, E[X] <: EdgeLikeIn[X], +This[X, Y[X] <: EdgeLikeIn[X]] <: GraphLike[X, Y[X], This] with Graph[X, Y[X]]] extends mutable.GraphLike[N, E, This] with constrained.GraphLike[N, E, This] with Growable[Param[N, E]] with Shrinkable[Param[N, E]] with Cloneable[Graph[N, E]] with Mutable

Self Type: This[N, E] with GraphLike[N, E, This] with Graph[N, E]

Linear Supertypes

constrained.GraphLike[N, E, This], Constrained[N, E], ConstraintHandlerMethods[N, E], ConstraintMethods[N, E], mutable.GraphLike[N, E, This], Mutable, EdgeOps[N, E, This], Cloneable[Graph[N, E]], Cloneable, Cloneable, Shrinkable[Param[N, E]], Growable[Param[N, E]], Clearable, collection.GraphLike[N, E, This], GraphDegree[N, E], GraphTraversal[N, E], GraphBase[N, E], Serializable, Serializable, SetLike[Param[N, E], This[N, E]], Subtractable[Param[N, E], This[N, E]], GenSetLike[Param[N, E], This[N, E]], (Param[N, E]) ⇒ Boolean, IterableLike[Param[N, E], This[N, E]], GenIterableLike[Param[N, E], This[N, E]], TraversableLike[Param[N, E], This[N, E]], GenTraversableLike[Param[N, E], This[N, E]], Parallelizable[Param[N, E], ParSet[Param[N, E]]], TraversableOnce[Param[N, E]], GenTraversableOnce[Param[N, E]], FilterMonadic[Param[N, E], This[N, E]], HasNewBuilder[Param[N, E], This[N, E]], Equals, AnyRef, Any

Known Subclasses

AdjacencyListGraph, DefaultGraphImpl, Graph, UserConstrainedGraphImpl

Ordering

Alphabetic
By Inheritance

Inherited

GraphLike
GraphLike
Constrained
ConstraintHandlerMethods
ConstraintMethods
GraphLike
Mutable
EdgeOps
Cloneable
Cloneable
Cloneable
Shrinkable
Growable
Clearable
GraphLike
GraphDegree
GraphTraversal
GraphBase
Serializable
Serializable
SetLike
Subtractable
GenSetLike
Function1
IterableLike
GenIterableLike
TraversableLike
GenTraversableLike
Parallelizable
TraversableOnce
GenTraversableOnce
FilterMonadic
HasNewBuilder
Equals
AnyRef
Any

Implicitly

by anyToNode
by MonadOps
by CollectionsHaveToParArray
by EdgeAssoc
by predicateToNodePredicate
by any2stringadd
by StringFormat
by Ensuring
by ArrowAssoc
by alternateImplicit

Hide All
Show All

Visibility

Public
All

Type Members

sealed abstract class AbstractTopologicalOrder[+A, +T] extends AbstractTraversable[T]

Definition Classes
GraphTraversal
abstract class Component extends Properties

Definition Classes
GraphTraversal
abstract class ComponentTraverser extends FluentProperties[ComponentTraverser] with Properties with Traversable[Component]

Definition Classes
GraphTraversal
abstract type Config <: GraphConfig with GenConstrainedConfig

Attributes
protected
Definition Classes
GraphLike → GraphLike
trait Cycle extends Path

Definition Classes
GraphTraversal
type CycleNodeOrTopologicalOrder = Either[(GraphLike.this)#NodeT, (GraphLike.this)#TopologicalOrder[(GraphLike.this)#NodeT]]

Definition Classes
GraphTraversal
trait DegreeFunction extends ((GraphDegree.this)#NodeT) ⇒ Int

Definition Classes
GraphDegree
type DegreeNodeSeqEntry = (Int, (GraphLike.this)#NodeT)

Definition Classes
GraphDegree
final class DegreeOrdering extends Ordering[(GraphDegree.this)#NodeT]

Definition Classes
GraphDegree
trait Edge extends Serializable

Definition Classes
GraphBase
class EdgeBase extends InnerEdgeParam[N, E, (collection.GraphLike.this)#NodeT, E] with (collection.GraphLike.this)#InnerEdge

Definition Classes
GraphLike
type EdgeFilter = ((GraphLike.this)#EdgeT) ⇒ Boolean

Definition Classes
GraphBase
sealed trait EdgeOrdering extends Ordering[GraphBase.EdgeT] with ElemOrdering

Definition Classes
GraphBase
trait EdgeSet extends Set[(mutable.GraphLike.this)#EdgeT] with (mutable.GraphLike.this)#EdgeSet

Definition Classes
GraphLike
abstract type EdgeSetT <: (GraphLike.this)#EdgeSet

Definition Classes
GraphLike → GraphLike → GraphBase
abstract type EdgeT <: InnerEdgeParam[N, E, (GraphLike.this)#NodeT, E] with (GraphLike.this)#InnerEdge with Serializable

Definition Classes
GraphLike → GraphBase
sealed trait ElemOrdering extends AnyRef

Attributes
protected
Definition Classes
GraphBase
trait ExtendedNodeVisitor[U] extends (GraphTraversal.NodeT) ⇒ U

Definition Classes
GraphTraversal
trait Filter[T] extends (T) ⇒ Boolean

Definition Classes
GraphDegree
abstract class FluentProperties[+This <: FluentProperties[This]] extends AnyRef

Attributes
protected
Definition Classes
GraphTraversal
trait InnerEdge extends (collection.GraphLike.this)#InnerEdge

Definition Classes
GraphLike
abstract class InnerEdgeTraverser extends TraverserMethods[GraphTraversal.EdgeT, InnerEdgeTraverser] with Traverser[GraphTraversal.EdgeT, InnerEdgeTraverser]

Definition Classes
GraphTraversal
sealed trait InnerElem extends AnyRef

Definition Classes
GraphBase
abstract class InnerElemTraverser extends TraverserMethods[GraphTraversal.InnerElem, InnerElemTraverser] with Traverser[GraphTraversal.InnerElem, InnerElemTraverser]

Attributes
protected
Definition Classes
GraphTraversal
trait InnerNode extends (mutable.GraphLike.this)#InnerNode with (mutable.GraphLike.this)#InnerNodeOps

Definition Classes
GraphLike
abstract class InnerNodeDownUpTraverser extends TraverserMethods[(Boolean, GraphTraversal.NodeT), InnerNodeDownUpTraverser] with Traverser[(Boolean, GraphTraversal.NodeT), InnerNodeDownUpTraverser]

Definition Classes
GraphTraversal
trait InnerNodeOps extends AnyRef

Definition Classes
EdgeOps
abstract class InnerNodeTraverser extends TraverserMethods[GraphTraversal.NodeT, InnerNodeTraverser] with Traverser[GraphTraversal.NodeT, InnerNodeTraverser]

Definition Classes
GraphTraversal
case class Layer extends Product with Serializable

Definition Classes
GraphTraversal
final class LayeredTopologicalOrder[+A] extends AbstractTopologicalOrder[A, (Int, Iterable[A])]

Definition Classes
GraphTraversal
type Layers = Traversable[(GraphLike.this)#Layer]

Definition Classes
GraphTraversal
trait Node extends Serializable

Definition Classes
GraphBase
abstract class NodeBase extends (collection.GraphLike.this)#NodeBase with InnerNodeParam[N] with (collection.GraphLike.this)#InnerNode

Attributes
protected
Definition Classes
GraphLike
type NodeFilter = ((GraphLike.this)#NodeT) ⇒ Boolean

Definition Classes
GraphBase
sealed trait NodeOrdering extends Ordering[GraphBase.NodeT] with ElemOrdering

Definition Classes
GraphBase
trait NodeSet extends (GraphLike.this)#NodeSet
abstract type NodeSetT <: (GraphLike.this)#NodeSet

Definition Classes
GraphLike → GraphLike → GraphBase
abstract type NodeT <: (GraphLike.this)#InnerNode

Definition Classes
GraphLike → GraphLike → GraphTraversal → GraphBase
abstract class OuterEdgeTraverser extends TraverserMethods[E[N], OuterEdgeTraverser] with Traverser[E[N], OuterEdgeTraverser]

Definition Classes
GraphTraversal
trait OuterElemTraverser extends TraverserMethods[OuterElem[N, E], OuterElemTraverser] with Traverser[OuterElem[N, E], OuterElemTraverser]

Definition Classes
GraphTraversal
abstract class OuterNodeDownUpTraverser extends TraverserMethods[(Boolean, N), OuterNodeDownUpTraverser] with Traverser[(Boolean, N), OuterNodeDownUpTraverser]

Definition Classes
GraphTraversal
abstract class OuterNodeTraverser extends TraverserMethods[N, OuterNodeTraverser] with Traverser[N, OuterNodeTraverser]

Definition Classes
GraphTraversal
trait Path extends Walk

Definition Classes
GraphTraversal
trait PathBuilder extends WalkBuilder with Builder[GraphTraversal.InnerElem, Path]

Definition Classes
GraphTraversal
trait Properties extends SubgraphProperties

Attributes
protected
Definition Classes
GraphTraversal
type Self = This[N, E]

Attributes
protected[this]
Definition Classes
TraversableLike
abstract class StrongComponentTraverser extends FluentProperties[StrongComponentTraverser] with Properties with Traversable[Component]

Definition Classes
GraphTraversal
trait SubgraphProperties extends AnyRef

Attributes
protected
Definition Classes
GraphTraversal
type ThisGraph = GraphLike.this

Attributes
protected
Definition Classes
GraphLike
final class TopologicalOrder[+A] extends AbstractTopologicalOrder[A, A]

Definition Classes
GraphTraversal
trait Traverser[A, +This <: Traverser[A, This]] extends TraverserMethods[A, This] with Properties with Traversable[A]

Definition Classes
GraphTraversal
trait TraverserInnerNode extends GraphTraversal.InnerNode

Definition Classes
GraphTraversal
abstract class TraverserMethods[A, +This <: TraverserMethods[A, This]] extends FluentProperties[This]

Attributes
protected
Definition Classes
GraphTraversal
trait Walk extends Traversable[GraphTraversal.InnerElem]

Definition Classes
GraphTraversal
trait WalkBuilder extends Builder[GraphTraversal.InnerElem, Walk]

Definition Classes
GraphTraversal
class Weight extends AnyRef

Definition Classes
GraphTraversal
class WithFilter extends FilterMonadic[A, Repr]

Definition Classes
TraversableLike

Abstract Value Members

abstract def +=#(edge: E[N]): GraphLike.this

Attributes
protected
Definition Classes
GraphLike
abstract def add(edge: E[N]): Boolean

Definition Classes
GraphLike
abstract def add(node: N): Boolean

Definition Classes
GraphLike
abstract def clear(): Unit

Definition Classes
Growable → Clearable
abstract def componentTraverser(parameters: Parameters, subgraphNodes: (GraphLike.this)#NodeFilter, subgraphEdges: (GraphLike.this)#EdgeFilter, ordering: (GraphLike.this)#ElemOrdering, maxWeight: Option[(GraphLike.this)#Weight]): (GraphLike.this)#ComponentTraverser

Definition Classes
GraphTraversal
implicit abstract def config: generic.GraphConstrainedCompanion.Config with (GraphLike.this)#Config

Definition Classes
GraphLike
abstract val constraintFactory: ConstraintCompanion[Constraint]

Definition Classes
GraphLike
implicit abstract val edgeT: ClassTag[E[N]]

Definition Classes
GraphLike
abstract def edges: (GraphLike.this)#EdgeSetT

Definition Classes
GraphBase
abstract def empty: This[N, E]

Definition Classes
SetLike
abstract val graphCompanion: GraphConstrainedCompanion[This]

Definition Classes
GraphLike → GraphLike
abstract def innerEdgeTraverser(root: (GraphLike.this)#NodeT, parameters: Parameters, subgraphNodes: (GraphLike.this)#NodeFilter, subgraphEdges: (GraphLike.this)#EdgeFilter, ordering: (GraphLike.this)#ElemOrdering, maxWeight: Option[(GraphLike.this)#Weight]): (GraphLike.this)#InnerEdgeTraverser

Definition Classes
GraphTraversal
abstract def innerElemTraverser(root: (GraphLike.this)#NodeT, parameters: Parameters, subgraphNodes: (GraphLike.this)#NodeFilter, subgraphEdges: (GraphLike.this)#EdgeFilter, ordering: (GraphLike.this)#ElemOrdering, maxWeight: Option[(GraphLike.this)#Weight]): (GraphLike.this)#InnerElemTraverser

Definition Classes
GraphTraversal
abstract def innerNodeDownUpTraverser(root: (GraphLike.this)#NodeT, parameters: Parameters, subgraphNodes: (GraphLike.this)#NodeFilter, subgraphEdges: (GraphLike.this)#EdgeFilter, ordering: (GraphLike.this)#ElemOrdering, maxWeight: Option[(GraphLike.this)#Weight]): (GraphLike.this)#InnerNodeDownUpTraverser

Definition Classes
GraphTraversal
abstract def innerNodeTraverser(root: (GraphLike.this)#NodeT, parameters: Parameters, subgraphNodes: (GraphLike.this)#NodeFilter, subgraphEdges: (GraphLike.this)#EdgeFilter, ordering: (GraphLike.this)#ElemOrdering, maxWeight: Option[(GraphLike.this)#Weight]): (GraphLike.this)#InnerNodeTraverser

Definition Classes
GraphTraversal
abstract def newEdge(innerEdge: E[(GraphLike.this)#NodeT]): (GraphLike.this)#EdgeT

Attributes
protected
Definition Classes
GraphBase
abstract def newNode(n: N): (GraphLike.this)#NodeT

Attributes
protected
Definition Classes
GraphBase
abstract def newPathBuilder(start: (GraphLike.this)#NodeT)(implicit sizeHint: Int, edgeSelector: ((GraphLike.this)#NodeT, (GraphLike.this)#NodeT) ⇒ Option[(GraphLike.this)#EdgeT]): (GraphLike.this)#PathBuilder

Definition Classes
GraphTraversal
abstract def newWalkBuilder(start: (GraphLike.this)#NodeT)(implicit sizeHint: Int, edgeSelector: ((GraphLike.this)#NodeT, (GraphLike.this)#NodeT) ⇒ Option[(GraphLike.this)#EdgeT]): (GraphLike.this)#WalkBuilder

Definition Classes
GraphTraversal
abstract def nodes: (GraphLike.this)#NodeSetT

Definition Classes
GraphBase
abstract def outerEdgeTraverser(root: (GraphLike.this)#NodeT, parameters: Parameters, subgraphNodes: (GraphLike.this)#NodeFilter, subgraphEdges: (GraphLike.this)#EdgeFilter, ordering: (GraphLike.this)#ElemOrdering, maxWeight: Option[(GraphLike.this)#Weight]): (GraphLike.this)#OuterEdgeTraverser

Definition Classes
GraphTraversal
abstract def outerElemTraverser(root: (GraphLike.this)#NodeT, parameters: Parameters, subgraphNodes: (GraphLike.this)#NodeFilter, subgraphEdges: (GraphLike.this)#EdgeFilter, ordering: (GraphLike.this)#ElemOrdering, maxWeight: Option[(GraphLike.this)#Weight]): (GraphLike.this)#OuterElemTraverser

Definition Classes
GraphTraversal
abstract def outerNodeDownUpTraverser(root: (GraphLike.this)#NodeT, parameters: Parameters, subgraphNodes: (GraphLike.this)#NodeFilter, subgraphEdges: (GraphLike.this)#EdgeFilter, ordering: (GraphLike.this)#ElemOrdering, maxWeight: Option[(GraphLike.this)#Weight]): (GraphLike.this)#OuterNodeDownUpTraverser

Definition Classes
GraphTraversal
abstract def outerNodeTraverser(root: (GraphLike.this)#NodeT, parameters: Parameters, subgraphNodes: (GraphLike.this)#NodeFilter, subgraphEdges: (GraphLike.this)#EdgeFilter, ordering: (GraphLike.this)#ElemOrdering, maxWeight: Option[(GraphLike.this)#Weight]): (GraphLike.this)#OuterNodeTraverser

Definition Classes
GraphTraversal
abstract def preAdd(edge: E[N]): PreCheckResult
This pre-check must return Abort if the addition is to be canceled, PostCheck if postAdd is to be called to decide or Complete if the outer edge is allowed to be added.
This pre-check must return Abort if the addition is to be canceled, PostCheck if postAdd is to be called to decide or Complete if the outer edge is allowed to be added. If postAdd has been implemented, this method may always return PostCheck. This pre-check may be omitted by letting it always return postCheck and overriding the corresponding post-check commit* method. Use self to access the associated graph.
edge
to be added.
returns
The results of the pre-check containing the follow-up activity and possibly any intermediate computation result to be used during the post-check. To add computation results PreCheckResult must be extended.

Definition Classes
ConstraintMethods
abstract def preAdd(node: N): PreCheckResult
This pre-check must return Abort if the addition is to be canceled, PostCheck if postAdd is to be called to decide or Complete if the outer node is allowed to be added.
This pre-check must return Abort if the addition is to be canceled, PostCheck if postAdd is to be called to decide or Complete if the outer node is allowed to be added. If postAdd has been implemented, this method may always return PostCheck. This pre-check may be omitted by letting it always return postCheck and overriding the corresponding post-check commit* method. Use self to access the associated graph.
node
to be added
returns
The results of the pre-check containing the follow-up activity and possibly any intermediate computation result to be used during the post-check. To add computation results PreCheckResult must be extended.

Definition Classes
ConstraintMethods
abstract def preSubtract(edge: Graph.EdgeT, simple: Boolean): PreCheckResult
This pre-check must return Abort if the subtraction of edge is to be canceled, PostCheck if postSubtract is to be called to decide or Complete if the the edge is allowed to be subtracted.
This pre-check must return Abort if the subtraction of edge is to be canceled, PostCheck if postSubtract is to be called to decide or Complete if the the edge is allowed to be subtracted. This pre-check may be omitted by letting it always return postCheck and overriding the corresponding post-check commit* method. Use self to access the associated graph.
edge
the inner edge to be subtracted.
simple
true for standard (edge-only by -), false for ripple (by -!) removal.
returns
The results of the pre-check containing the follow-up activity and possibly any intermediate computation result to be used during the post-check. To add computation results PreCheckResult must be extended.

Definition Classes
ConstraintMethods
abstract def preSubtract(node: Graph.NodeT, forced: Boolean): PreCheckResult
This pre-check must return Abort if the subtraction of node is to be canceled, PostCheck if postSubtract is to be called to decide or Complete if the the node is allowed to be subtracted.
This pre-check must return Abort if the subtraction of node is to be canceled, PostCheck if postSubtract is to be called to decide or Complete if the the node is allowed to be subtracted. This pre-check may be omitted by letting it always return postCheck and overriding the corresponding post-check commit* method. Use self to access the associated graph.
node
the inner to be subtracted.
forced
true for standard (ripple by -), false for gentle (by -?) removal.
returns
The results of the pre-check containing the follow-up activity and possibly any intermediate computation result to be used during the post-check. To add computation results PreCheckResult must be extended.

Definition Classes
ConstraintMethods
abstract val self: constrained.Graph[N, E]
When extending Constraint, self will denote the attached constrained graph.
When extending Constraint, self will denote the attached constrained graph. The factory methods of the companion object scalax.collection.constrained.Graph initialize self to the correct graph instance. When extending Constrained, self will denote this graph.

Definition Classes
ConstraintMethods
abstract def seq: Set[Param[N, E]]

Definition Classes
GenSetLike → Parallelizable → GenTraversableOnce
abstract def strongComponentTraverser(parameters: Parameters, subgraphNodes: (GraphLike.this)#NodeFilter, subgraphEdges: (GraphLike.this)#EdgeFilter, ordering: (GraphLike.this)#ElemOrdering, maxWeight: Option[(GraphLike.this)#Weight]): (GraphLike.this)#StrongComponentTraverser

Definition Classes
GraphTraversal
abstract def upsert(edge: E[N]): Boolean

Definition Classes
GraphLike

Concrete Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
def &(that: GenSet[Param[N, E]]): This[N, E]

Definition Classes
GenSetLike
def &=(coll: Iterable[Param[N, E]]): GraphLike.this

Definition Classes
GraphLike
def &~(that: GenSet[Param[N, E]]): This[N, E]

Definition Classes
GenSetLike
def +(node: N): This[N, E]

Definition Classes
GraphLike → GraphLike → GraphLike
def +(elem: Param[N, E]): This[N, E]

Definition Classes
GraphLike → SetLike → GenSetLike
def +(elem1: Param[N, E], elem2: Param[N, E], elems: Param[N, E]*): This[N, E]

Definition Classes
SetLike
final def +#(edge: E[N]): This[N, E]

Attributes
protected
Definition Classes
GraphLike → GraphLike
Annotations
@inline()
def ++(elems: GenTraversableOnce[Param[N, E]]): GraphLike.this

Definition Classes
GraphLike → GraphLike → SetLike
def ++[B >: Param[N, E], That](that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[This[N, E], B, That]): That

Definition Classes
TraversableLike → GenTraversableLike
def ++:[B >: Param[N, E], That](that: Traversable[B])(implicit bf: CanBuildFrom[This[N, E], B, That]): That

Definition Classes
TraversableLike
def ++:[B >: Param[N, E], That](that: TraversableOnce[B])(implicit bf: CanBuildFrom[This[N, E], B, That]): That

Definition Classes
TraversableLike
def ++=(elems: TraversableOnce[Param[N, E]]): GraphLike.this

Definition Classes
GraphLike → GraphLike → Growable
def +=(elem: Param[N, E]): GraphLike.this

Definition Classes
GraphLike → Growable
final def +=(node: N): GraphLike.this

Definition Classes
GraphLike
Annotations
@inline()
def +=(elem1: Param[N, E], elem2: Param[N, E], elems: Param[N, E]*): GraphLike.this

Definition Classes
Growable
final def +~%+=[EE[X] <: E[X] with EdgeLikeIn[X] with WLHyperEdgeBound[_, EE], L](node_1: N, node_2: N, nodes: N*)(weight: Double, label: L)(implicit edgeFactory: WLHyperEdgeCompanion[EE], endpointsKind: CollectionKind): GraphLike.this

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

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

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

Definition Classes
EdgeOps
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]): GraphLike.this

Definition Classes
EdgeOps
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]): GraphLike.this

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

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

Definition Classes
EdgeOps
Annotations
@inline()
final def -(edge: E[N]): This[N, E]

Definition Classes
GraphLike
Annotations
@inline()
final def -(node: N): This[N, E]

Definition Classes
GraphLike → GraphLike
Annotations
@inline()
def -(elem: Param[N, E]): This[N, E]

Definition Classes
GraphLike → SetLike → Subtractable → GenSetLike
def -(elem1: Param[N, E], elem2: Param[N, E], elems: Param[N, E]*): This[N, E]

Definition Classes
Subtractable
final def -!(edge: E[N]): This[N, E]

Definition Classes
GraphLike
Annotations
@inline()
def -!(elem: Param[N, E]): This[N, E]

Definition Classes
GraphLike
final def -!#(edge: E[N]): This[N, E]

Attributes
protected
Definition Classes
GraphLike → GraphLike
Annotations
@inline()
def -!=(elem: Param[N, E]): GraphLike.this

Definition Classes
GraphLike
final def -!=#(edge: E[N]): GraphLike.this

Attributes
protected
Definition Classes
GraphLike
Annotations
@inline()
final def -#(edge: E[N]): This[N, E]

Attributes
protected
Definition Classes
GraphLike → GraphLike
Annotations
@inline()
def --(elems: GenTraversableOnce[Param[N, E]]): This[N, E] with constrained.GraphLike[N, E, This] with Set[Param[N, E]] with constrained.Graph[N, E]

Definition Classes
GraphLike → GraphLike → Subtractable
def --!(elems: GenTraversableOnce[Param[N, E]]): This[N, E]

Definition Classes
GraphLike
final def --!=(coll: Iterable[Param[N, E]]): This[N, E]

Definition Classes
GraphLike
Annotations
@inline()
def --=(elems: TraversableOnce[Param[N, E]]): GraphLike.this

Definition Classes
GraphLike → Shrinkable
def -=(elem: Param[N, E]): GraphLike.this

Definition Classes
GraphLike → Shrinkable
final def -=(node: N): GraphLike.this

Definition Classes
GraphLike
Annotations
@inline()
def -=(elem1: Param[N, E], elem2: Param[N, E], elems: Param[N, E]*): GraphLike.this

Definition Classes
Shrinkable
final def -=#(edge: E[N]): GraphLike.this

Attributes
protected
Definition Classes
GraphLike
Annotations
@inline()
def ->[B](y: B): (GraphLike[N, E, This], B)

Implicit
This member is added by an implicit conversion from GraphLike[N, E, This] to ArrowAssoc[GraphLike[N, E, This]] performed by method ArrowAssoc in scala.Predef.
Definition Classes
ArrowAssoc
Annotations
@inline()
final def -?(node: N): This[N, E]

Definition Classes
GraphLike → GraphLike
Annotations
@inline()
final def -?=(node: N): GraphLike.this

Definition Classes
GraphLike
Annotations
@inline()
def /:[B](z: B)(op: (B, Param[N, E]) ⇒ B): B

Definition Classes
TraversableOnce → GenTraversableOnce
def :\[B](z: B)(op: (Param[N, E], B) ⇒ B): B

Definition Classes
TraversableOnce → GenTraversableOnce
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def addAndGet(edge: E[N]): (GraphLike.this)#EdgeT

Definition Classes
GraphLike
Annotations
@inline()
final def addAndGet(node: N): (GraphLike.this)#NodeT

Definition Classes
GraphLike
Annotations
@inline()
def addAndGetEdge(node_1: N, node_2: N, nodes: N*)(implicit edgeFactory: HyperEdgeCompanion[E], endpointsKind: CollectionKind): (GraphLike.this)#EdgeT

Definition Classes
EdgeOps
final def addAndGetEdge(node_1: N, node_2: N)(implicit edgeFactory: EdgeCompanion[E]): (GraphLike.this)#EdgeT

Definition Classes
EdgeOps
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.this)#EdgeT

Definition Classes
EdgeOps
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.this)#EdgeT

Definition Classes
EdgeOps
Annotations
@inline()
def addAndGetWEdge[EE[X] <: E[X] with EdgeLikeIn[X] with WHyperEdgeBound[_, EE]](node_1: N, node_2: N, nodes: N*)(weight: Double)(implicit edgeFactory: WHyperEdgeCompanion[EE], endpointsKind: CollectionKind): (GraphLike.this)#EdgeT

Definition Classes
EdgeOps
final def addAndGetWEdge[EE[X] <: E[X] with EdgeLikeIn[X] with WEdgeBound[_, EE]](node_1: N, node_2: N)(weight: Double)(implicit edgeFactory: WEdgeCompanion[EE]): (GraphLike.this)#EdgeT

Definition Classes
EdgeOps
Annotations
@inline()
def addAndGetWLEdge[EE[X] <: E[X] with EdgeLikeIn[X] with WLHyperEdgeBound[_, EE], L](node_1: N, node_2: N, nodes: N*)(weight: Double, label: L)(implicit edgeFactory: WLHyperEdgeCompanion[EE], endpointsKind: CollectionKind): (GraphLike.this)#EdgeT

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

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

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

Definition Classes
EdgeOps
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

Definition Classes
EdgeOps
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

Definition Classes
EdgeOps
Annotations
@inline()
def addString(b: StringBuilder): StringBuilder

Definition Classes
TraversableOnce
def addString(b: StringBuilder, sep: String): StringBuilder

Definition Classes
TraversableOnce
def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder

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

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

Definition Classes
EdgeOps
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: Double, label: L)(implicit edgeFactory: WLHyperEdgeCompanion[EE], endpointsKind: CollectionKind): Boolean

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

Definition Classes
EdgeOps
Annotations
@inline()
def aggregate[B](z: ⇒ B)(seqop: (B, Param[N, E]) ⇒ B, combop: (B, B) ⇒ B): B

Definition Classes
TraversableOnce → GenTraversableOnce
def allNodes(passedNodes: Traversable[N], passedEdges: Traversable[E[N]]): Set[N]
Consolidates all outer nodes of the arguments by adding the edge ends of passedEdges to passedNodes.
Consolidates all outer nodes of the arguments by adding the edge ends of passedEdges to passedNodes.

Attributes
protected
Definition Classes
ConstraintMethods
def andThen[A](g: (Boolean) ⇒ A): (Param[N, E]) ⇒ A

Definition Classes
Function1
Annotations
@unspecialized()
final val anyEdge: (GraphLike.this)#EdgeFilter

Definition Classes
GraphBase
final def anyEdgeSelector(from: (GraphLike.this)#NodeT, to: (GraphLike.this)#NodeT): Option[(GraphLike.this)#EdgeT]

Definition Classes
GraphTraversal
Annotations
@inline()
final val anyNode: (GraphLike.this)#NodeFilter

Definition Classes
GraphBase
final lazy val anyOrdering: AnyOrdering[N]

Attributes
protected
Definition Classes
GraphBase
def apply(elem: Param[N, E]): Boolean

Definition Classes
GenSetLike → Function1
final def asInstanceOf[T0]: T0

Definition Classes
Any
def asSortedString(nodeSeparator: String, edgeSeparator: String, nodesEdgesSeparator: String, withNodesEdgesPrefix: Boolean)(implicit ordNode: (GraphLike.this)#NodeOrdering, ordEdge: (GraphLike.this)#EdgeOrdering): String

Definition Classes
GraphLike
final def bulkOp(elems: GenTraversableOnce[Param[N, E]], isPlusPlus: Boolean): This[N, E]

Attributes
protected
Definition Classes
GraphLike
def canEqual(that: Any): Boolean

Definition Classes
IterableLike → Equals
def checkSuspended: Boolean

Attributes
protected
Definition Classes
GraphLike
def checkedAdd[G >: This[N, E]](contained: ⇒ Boolean, preAdd: ⇒ PreCheckResult, copy: ⇒ G, nodes: ⇒ Traversable[N], edges: ⇒ Traversable[E[N]]): This[N, E]
generic checked addition
generic checked addition

Attributes
protected
def clone(): This[N, E]

Definition Classes
GraphLike → Cloneable → AnyRef
def collect[B, That](pf: PartialFunction[Param[N, E], B])(implicit bf: CanBuildFrom[This[N, E], B, That]): That

Definition Classes
TraversableLike → GenTraversableLike
def collectFirst[B](pf: PartialFunction[Param[N, E], B]): Option[B]

Definition Classes
TraversableOnce
def compose[A](g: (A) ⇒ Param[N, E]): (A) ⇒ Boolean

Definition Classes
Function1
Annotations
@unspecialized()
def contains(elem: Param[N, E]): Boolean

Definition Classes
GraphLike → SetLike → GenSetLike
def copyToArray[B >: Param[N, E]](xs: Array[B], start: Int, len: Int): Unit

Definition Classes
IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce
def copyToArray[B >: Param[N, E]](xs: Array[B]): Unit

Definition Classes
TraversableOnce → GenTraversableOnce
def copyToArray[B >: Param[N, E]](xs: Array[B], start: Int): Unit

Definition Classes
TraversableOnce → GenTraversableOnce
def copyToBuffer[B >: Param[N, E]](dest: Buffer[B]): Unit

Definition Classes
TraversableOnce
def count(p: (Param[N, E]) ⇒ Boolean): Int

Definition Classes
TraversableOnce → GenTraversableOnce
final lazy val defaultEdgeOrdering: (GraphLike.this)#EdgeOrdering

Definition Classes
GraphBase
final lazy val defaultNodeOrdering: (GraphLike.this)#NodeOrdering

Definition Classes
GraphBase
final def defaultPathSize: Int

Attributes
protected
Definition Classes
GraphTraversal
Annotations
@inline()
def degreeCount(implicit nodeDegree: (GraphLike.this)#DegreeFunction, degreeFilter: (Int) ⇒ Boolean): SortedMap[Int, Int]

Definition Classes
GraphDegree
def degreeNodeSeq(implicit nodeDegree: (GraphLike.this)#DegreeFunction, degreeFilter: (Int) ⇒ Boolean): Seq[(GraphLike.this)#DegreeNodeSeqEntry]

Definition Classes
GraphDegree
def degreeNodesMap(implicit nodeDegree: (GraphLike.this)#DegreeFunction, degreeFilter: (Int) ⇒ Boolean): SortedMap[Int, AnySet[(GraphLike.this)#NodeT]]

Definition Classes
GraphDegree
def degreeSeq(implicit nodeDegree: (GraphLike.this)#DegreeFunction, degreeFilter: (Int) ⇒ Boolean): Seq[Int]

Definition Classes
GraphDegree
def degreeSet(implicit nodeDegree: (GraphLike.this)#DegreeFunction, degreeFilter: (Int) ⇒ Boolean): SortedSet[Int]

Definition Classes
GraphDegree
def diff(that: GenSet[Param[N, E]]): This[N, E]

Definition Classes
SetLike → GenSetLike
def drop(n: Int): This[N, E]

Definition Classes
IterableLike → TraversableLike → GenTraversableLike
def dropRight(n: Int): This[N, E]

Definition Classes
IterableLike
def dropWhile(p: (Param[N, E]) ⇒ Boolean): This[N, E]

Definition Classes
TraversableLike → GenTraversableLike
implicit final def edgeToEdgeCont(e: E[N]): E[(GraphLike.this)#NodeT]

Attributes
protected
Definition Classes
GraphBase
def ensuring(cond: (GraphLike[N, E, This]) ⇒ Boolean, msg: ⇒ Any): GraphLike[N, E, This]

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

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

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

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

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

Definition Classes
GraphLike → GenSetLike → Equals → AnyRef → Any
def exists(p: (Param[N, E]) ⇒ Boolean): Boolean

Definition Classes
IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce
def filter(p: (Param[N, E]) ⇒ Boolean): This[N, E]

Definition Classes
TraversableLike → GenTraversableLike
def filterNot(p: (Param[N, E]) ⇒ Boolean): This[N, E]

Definition Classes
TraversableLike → GenTraversableLike
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def find(outerEdge: E[N]): Option[(GraphLike.this)#EdgeT]

Definition Classes
GraphLike
Annotations
@inline()
final def find(outerNode: N): Option[(GraphLike.this)#NodeT]

Definition Classes
GraphLike
Annotations
@inline()
def find(p: (Param[N, E]) ⇒ Boolean): Option[Param[N, E]]

Definition Classes
IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce
final def findCycle[U](implicit visitor: ((GraphLike.this)#InnerElem) ⇒ U): Option[(GraphLike.this)#Cycle]

Definition Classes
GraphTraversal
final def findCycleContaining[U](node: (GraphLike.this)#NodeT)(implicit visitor: ((GraphLike.this)#InnerElem) ⇒ U): Option[(GraphLike.this)#Cycle]

Definition Classes
GraphTraversal
def flatMap[B, That](f: (Param[N, E]) ⇒ GenTraversableOnce[B])(implicit bf: CanBuildFrom[This[N, E], B, That]): That

Definition Classes
TraversableLike → GenTraversableLike → FilterMonadic
def fold[A1 >: Param[N, E]](z: A1)(op: (A1, A1) ⇒ A1): A1

Definition Classes
TraversableOnce → GenTraversableOnce
def foldLeft[B](z: B)(op: (B, Param[N, E]) ⇒ B): B

Definition Classes
TraversableOnce → GenTraversableOnce
def foldRight[B](z: B)(op: (Param[N, E], B) ⇒ B): B

Definition Classes
IterableLike → TraversableOnce → GenTraversableOnce
def forall(p: (Param[N, E]) ⇒ Boolean): Boolean

Definition Classes
IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce
def foreach[U](f: (Param[N, E]) ⇒ U): Unit

Definition Classes
IterableLike → TraversableLike → GenTraversableLike → TraversableOnce → GenTraversableOnce → FilterMonadic
def formatted(fmtstr: String): String

Implicit
This member is added by an implicit conversion from GraphLike[N, E, This] to StringFormat[GraphLike[N, E, This]] performed by method StringFormat in scala.Predef.
Definition Classes
StringFormat
Annotations
@inline()
final def get(outerEdge: E[N]): (GraphLike.this)#EdgeT

Definition Classes
GraphLike
Annotations
@inline()
final def get(outerNode: N): (GraphLike.this)#NodeT

Definition Classes
GraphLike
Annotations
@inline()
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
Annotations
@native()
final def getOrElse(outerEdge: E[N], default: (GraphLike.this)#EdgeT): (GraphLike.this)#EdgeT

Definition Classes
GraphLike
Annotations
@inline()
final def getOrElse(outerNode: N, default: (GraphLike.this)#NodeT): (GraphLike.this)#NodeT

Definition Classes
GraphLike
Annotations
@inline()
def graphSize: Int

Definition Classes
GraphBase
def groupBy[K](f: (Param[N, E]) ⇒ K): Map[K, This[N, E]]

Definition Classes
TraversableLike → GenTraversableLike
def grouped(size: Int): Iterator[This[N, E]]

Definition Classes
IterableLike
def hasDefiniteSize: Boolean

Definition Classes
TraversableLike → TraversableOnce → GenTraversableOnce
def hashCode(): Int

Definition Classes
GenSetLike → AnyRef → Any
def having(node: (GraphLike.this)#NodeFilter, edge: (GraphLike.this)#EdgeFilter): PartialFunction[Param[N, E], Boolean]

Definition Classes
GraphLike
def head: Param[N, E]

Definition Classes
IterableLike → TraversableLike → GenTraversableLike
def headOption: Option[Param[N, E]]

Definition Classes
TraversableLike → GenTraversableLike
def init: This[N, E]

Definition Classes
TraversableLike → GenTraversableLike
def initialize(nodes: Traversable[N], edges: Traversable[E[N]]): Unit

Attributes
protected
Definition Classes
GraphBase
def inits: Iterator[This[N, E]]

Definition Classes
TraversableLike
def intersect(that: GenSet[Param[N, E]]): This[N, E]

Definition Classes
GenSetLike
final def isAcyclic: Boolean

Definition Classes
GraphTraversal
Annotations
@inline()
def isComplete: Boolean

Definition Classes
GraphTraversal
def isConnected: Boolean

Definition Classes
GraphTraversal
final def isCustomEdgeFilter(f: (GraphLike.this)#EdgeFilter): Boolean

Definition Classes
GraphBase
Annotations
@inline()
final def isCustomNodeFilter(f: (GraphLike.this)#NodeFilter): Boolean

Definition Classes
GraphBase
Annotations
@inline()
final def isCyclic: Boolean

Definition Classes
GraphTraversal
Annotations
@inline()
def isDefined: Boolean

Implicit
This member is added by an implicit conversion from GraphLike[N, E, This] to OuterNode[GraphLike[N, E, This]] performed by method anyToNode in scalax.collection.GraphPredef.
Definition Classes
Param
def isDirected: Boolean

Definition Classes
GraphLike → GraphBase
final val isDirectedT: Boolean

Attributes
protected
Definition Classes
GraphLike
final def isEdge: Boolean

Implicit
This member is added by an implicit conversion from GraphLike[N, E, This] to OuterNode[GraphLike[N, E, This]] performed by method anyToNode in scalax.collection.GraphPredef.
Definition Classes
Param
def isEmpty: Boolean

Definition Classes
SetLike → IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce
def isHyper: Boolean

Definition Classes
GraphLike → GraphBase
final val isHyperT: Boolean

Attributes
protected
Definition Classes
GraphLike
def isIn: Boolean

Implicit
This member is added by an implicit conversion from GraphLike[N, E, This] to OuterNode[GraphLike[N, E, This]] performed by method anyToNode in scalax.collection.GraphPredef.
Definition Classes
InParam → Param
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def isMixed: Boolean

Definition Classes
GraphLike → GraphBase
def isMulti: Boolean

Definition Classes
GraphLike → GraphBase
final val isMultiT: Boolean

Attributes
protected
Definition Classes
GraphLike
def isNode: Boolean

Implicit
This member is added by an implicit conversion from GraphLike[N, E, This] to OuterNode[GraphLike[N, E, This]] performed by method anyToNode in scalax.collection.GraphPredef.
Definition Classes
NodeParam
final def isOut: Boolean

Implicit
This member is added by an implicit conversion from GraphLike[N, E, This] to OuterNode[GraphLike[N, E, This]] performed by method anyToNode in scalax.collection.GraphPredef.
Definition Classes
Param
final def isTraversableAgain: Boolean

Definition Classes
TraversableLike → GenTraversableLike → GenTraversableOnce
final def isTrivial: Boolean

Definition Classes
GraphBase
Annotations
@inline()
def iterator: Iterator[Param[N, E]]

Definition Classes
GraphLike → GenSetLike → IterableLike → GenIterableLike
def last: Param[N, E]

Definition Classes
TraversableLike → GenTraversableLike
def lastOption: Option[Param[N, E]]

Definition Classes
TraversableLike → GenTraversableLike
def map[B, That](f: (Param[N, E]) ⇒ B)(implicit bf: CanBuildFrom[This[N, E], B, That]): That

Definition Classes
SetLike → TraversableLike → GenTraversableLike → FilterMonadic
Annotations
@migration
Migration
(Changed in version 2.8.0) Set.map now returns a Set, so it will discard duplicate values.
def max[B >: Param[N, E]](implicit cmp: Ordering[B]): Param[N, E]

Definition Classes
TraversableOnce → GenTraversableOnce
def maxBy[B](f: (Param[N, E]) ⇒ B)(implicit cmp: Ordering[B]): Param[N, E]

Definition Classes
TraversableOnce → GenTraversableOnce
def maxDegree(implicit nodeDegree: (GraphLike.this)#DegreeFunction, degreeFilter: (Int) ⇒ Boolean): Int

Definition Classes
GraphDegree
def min[B >: Param[N, E]](implicit cmp: Ordering[B]): Param[N, E]

Definition Classes
TraversableOnce → GenTraversableOnce
def minBy[B](f: (Param[N, E]) ⇒ B)(implicit cmp: Ordering[B]): Param[N, E]

Definition Classes
TraversableOnce → GenTraversableOnce
def minDegree(implicit nodeDegree: (GraphLike.this)#DegreeFunction, degreeFilter: (Int) ⇒ Boolean): Int

Definition Classes
GraphDegree
def minusMinus(delNodes: Traversable[N], delEdges: Traversable[E[N]]): This[N, E]

Attributes
protected
Definition Classes
GraphLike → GraphLike
def minusMinusNodesEdges(delNodes: Traversable[N], delEdges: Traversable[E[N]]): (Set[N], Set[E[N]])

Attributes
protected
Definition Classes
GraphLike
def mkString: String

Definition Classes
TraversableOnce → GenTraversableOnce
def mkString(sep: String): String

Definition Classes
TraversableOnce → GenTraversableOnce
def mkString(start: String, sep: String, end: String): String

Definition Classes
TraversableOnce → GenTraversableOnce
val n1: GraphLike[N, E, This]

Implicit
This member is added by an implicit conversion from GraphLike[N, E, This] to EdgeAssoc[GraphLike[N, E, This]] performed by method EdgeAssoc in scalax.collection.GraphPredef.
Definition Classes
EdgeAssoc
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def newBuilder: Builder[Param[N, E], This[N, E]]

Attributes
protected[this]
Definition Classes
SetLike → TraversableLike → HasNewBuilder
final val noNode: (GraphLike.this)#NodeFilter

Definition Classes
GraphBase
def nodesToAdd(passedNodes: Traversable[N], passedEdges: Traversable[E[N]]): Set[N]

Attributes
protected
Definition Classes
ConstraintMethods
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[(GraphLike.this)#NodeT]

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

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

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

Attributes
protected
Definition Classes
EdgeOps
Annotations
@inline()
def nodesToEdgeCont(factory: EdgeCompanion[E], node_1: N, node_2: N): E[(GraphLike.this)#NodeT]

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

Attributes
protected[scalax.collection]
Definition Classes
EdgeOps
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.this)#EdgeT

Attributes
protected
Definition Classes
EdgeOps
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.this)#EdgeT

Attributes
protected
Definition Classes
EdgeOps
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[(GraphLike.this)#NodeT]

Attributes
protected[scalax.collection]
Definition Classes
EdgeOps
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): E[(GraphLike.this)#NodeT]

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

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

Attributes
protected
Definition Classes
EdgeOps
Annotations
@inline()
def nodesToWEdgeCont[EE[X] <: E[X] with EdgeLikeIn[X] with WEdgeBound[_, EE]](factory: WEdgeCompanion[EE], weight: Double, node_1: N, node_2: N): E[(GraphLike.this)#NodeT]

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

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

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

Attributes
protected
Definition Classes
EdgeOps
Annotations
@inline()
def nodesToWLEdgeCont[EE[X] <: E[X] with EdgeLikeIn[X] with WLEdgeBound[_, EE], L](factory: WLEdgeCompanion[EE], weight: Double, label: L, node_1: N, node_2: N): E[(GraphLike.this)#NodeT]

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

Attributes
protected[scalax.collection]
Definition Classes
EdgeOps
def nonEmpty: Boolean

Definition Classes
TraversableOnce → GenTraversableOnce
final def nonTrivial: Boolean

Definition Classes
GraphBase
Annotations
@inline()
final def notify(): Unit

Definition Classes
AnyRef
Annotations
@native()
final def notifyAll(): Unit

Definition Classes
AnyRef
Annotations
@native()
def onAdditionRefused(refusedNodes: Traversable[N], refusedEdges: Traversable[E[N]], graph: constrained.Graph[N, E]): Boolean
This handler is called whenever an addition violates the constraints.
This handler is called whenever an addition violates the constraints. The provided default implementation is empty.
refusedNodes
the nodes passed to preAdd.
refusedEdges
the edges passed to preAdd.
returns
must be true if the handler has been overridden but it doesn't throw an exception.

Definition Classes
ConstraintHandlerMethods
def onSubtractionRefused(refusedNodes: Traversable[Graph.NodeT], refusedEdges: Traversable[Graph.EdgeT], graph: constrained.Graph[N, E]): Boolean
This handler is called whenever a subtraction violates the constraints.
This handler is called whenever a subtraction violates the constraints. The provided default implementation is empty.
refusedNodes
the nodes passed to preSubtract.
refusedEdges
the edges passed to preSubtract.
returns
must be true if the handler has been overridden but it doesn't throw an exception.

Definition Classes
ConstraintHandlerMethods
def order: Int

Definition Classes
GraphBase
def par: ParSet[Param[N, E]]

Definition Classes
Parallelizable
def parCombiner: Combiner[Param[N, E], ParSet[Param[N, E]]]

Attributes
protected[this]
Definition Classes
SetLike → TraversableLike → Parallelizable
final def partition(elems: GenTraversableOnce[Param[N, E]]): Partitions[N, E]

Attributes
protected
Definition Classes
GraphLike
def partition(p: (Param[N, E]) ⇒ Boolean): (This[N, E], This[N, E])

Definition Classes
TraversableLike → GenTraversableLike
def plusPlus(newNodes: Traversable[N], newEdges: Traversable[E[N]]): This[N, E]

Attributes
protected
Definition Classes
GraphLike → GraphLike
def postAdd(newGraph: constrained.Graph[N, E], passedNodes: Traversable[N], passedEdges: Traversable[E[N]], preCheck: PreCheckResult): Boolean
This post-check must return whether newGraph should be committed or the add operation is to be rolled back.
This post-check must return whether newGraph should be committed or the add operation is to be rolled back. Use self to access the associated graph. For immutable graphs, self maintains the state before the addition but for mutable graphs, it is already mutated to the required state.
newGraph
the after-addition would-be graph waiting for commit.
passedNodes
nodes passed to the running add operation
passedEdges
edges passed to the running add operation
preCheck
The results of the pre-check containing the follow-up activity and possibly any intermediate computation result to be used during the post-check. To add computation results PreCheckResult must be extended.

Definition Classes
ConstraintMethods
def postSubtract(newGraph: constrained.Graph[N, E], passedNodes: Traversable[N], passedEdges: Traversable[E[N]], preCheck: PreCheckResult): Boolean
This post-check must return whether newGraph should be committed or the subtraction is to be rolled back.
This post-check must return whether newGraph should be committed or the subtraction is to be rolled back. Use self to access the associated graph. For immutable graphs, self maintains the state before the addition but for mutable graphs, it is already mutated to the required state.
newGraph
the after-subtraction would-be graph waiting for commit.
preCheck
The results of the pre-check containing the follow-up activity and possibly any intermediate computation result to be used during the post-check. To add computation results PreCheckResult must be extended.

Definition Classes
ConstraintMethods
def preAdd(elems: InParam[N, E]*): PreCheckResult
This pre-check must return Abort if the addition of the outer nodes and/or edges in elems is to be canceled, PostCheck if postAdd is to be called to decide or Complete if the the outer nodes and/or edges are allowed to be added.
This pre-check must return Abort if the addition of the outer nodes and/or edges in elems is to be canceled, PostCheck if postAdd is to be called to decide or Complete if the the outer nodes and/or edges are allowed to be added. If postAdd has been implemented, this method may always return PostCheck. The default implementation calls preAdd(node)/preAdd(edge) element-wise. As for most cases this won't be satisfactory a domain-specific implementation should be provided. Use self to access the associated graph.
elems
nodes and/or edges to be added possibly containing duplicates.
returns
The results of the pre-check containing the follow-up activity and possibly any intermediate computation result to be used during the post-check. To add computation results PreCheckResult must be extended.

Definition Classes
ConstraintMethods
def preCreate(nodes: Traversable[N], edges: Traversable[E[N]]): PreCheckResult
This pre-check is called on constructing a graph through its companion object.
This pre-check is called on constructing a graph through its companion object. It must return whether the graph is allowed to be populated with nodes and edges. The default implementation calls preAdd for each node and edge.
Note that nodes and edges coming from node/edge input streams are not checked. So when utilizing streams the post check postAdd must be served.
nodes
the outer nodes the graph is to be populated with; nodes being edge ends may but need not be contained in nodes.
edges
the outer edges the graph is to be populated with.
returns
The results of the pre-check containing the follow-up activity and possibly any intermediate computation result to be used during the post-check. To add computation results PreCheckResult must be extended.

Definition Classes
ConstraintMethods
def preSubtract(nodes: ⇒ Set[Graph.NodeT], edges: ⇒ Set[Graph.EdgeT], simple: Boolean): PreCheckResult
This pre-check must return Abort if the subtraction of nodes and/or edges is to be canceled, PostCheck if postSubtract is to be called to decide or Complete if nodes and/or edges are allowed to be subtracted.
This pre-check must return Abort if the subtraction of nodes and/or edges is to be canceled, PostCheck if postSubtract is to be called to decide or Complete if nodes and/or edges are allowed to be subtracted. It is typically triggered by the -- operation. The default implementation element-wise calls preSubtract(node, simple) or preSubtract(edge, simple), respectively. As for most cases this won't be satisfactory a domain-specific implementation should be provided. Use self to access the associated graph.
nodes
the inner nodes to be subtracted not necessarily including the ends of edges to be subtracted. Call allNodes to get the complete set of nodes to be subtracted.
edges
the inner edges to be subtracted.
simple
true for standard (edge-only by -), false for ripple (by -!) removal.
returns
The results of the pre-check containing the follow-up activity and possibly any intermediate computation result to be used during the post-check. To add computation results PreCheckResult must be extended.

Definition Classes
ConstraintMethods
def product[B >: Param[N, E]](implicit num: Numeric[B]): B

Definition Classes
TraversableOnce → GenTraversableOnce
def reduce[A1 >: Param[N, E]](op: (A1, A1) ⇒ A1): A1

Definition Classes
TraversableOnce → GenTraversableOnce
def reduceLeft[B >: Param[N, E]](op: (B, Param[N, E]) ⇒ B): B

Definition Classes
TraversableOnce
def reduceLeftOption[B >: Param[N, E]](op: (B, Param[N, E]) ⇒ B): Option[B]

Definition Classes
TraversableOnce → GenTraversableOnce
def reduceOption[A1 >: Param[N, E]](op: (A1, A1) ⇒ A1): Option[A1]

Definition Classes
TraversableOnce → GenTraversableOnce
def reduceRight[B >: Param[N, E]](op: (Param[N, E], B) ⇒ B): B

Definition Classes
IterableLike → TraversableOnce → GenTraversableOnce
def reduceRightOption[B >: Param[N, E]](op: (Param[N, E], B) ⇒ B): Option[B]

Definition Classes
TraversableOnce → GenTraversableOnce
final def remove(edge: E[N]): Boolean

Definition Classes
GraphLike
Annotations
@inline()
final def remove(node: N): Boolean

Definition Classes
GraphLike
Annotations
@inline()
final def removeGently(node: N): Boolean

Definition Classes
GraphLike
final def removeWithNodes(edge: E[N]): Boolean

Definition Classes
GraphLike
Annotations
@inline()
def repr: This[N, E]

Definition Classes
TraversableLike → GenTraversableLike
def reversed: List[Param[N, E]]

Attributes
protected[this]
Definition Classes
TraversableOnce
def sameElements[B >: Param[N, E]](that: GenIterable[B]): Boolean

Definition Classes
IterableLike → GenIterableLike
def scan[B >: Param[N, E], That](z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[This[N, E], B, That]): That

Definition Classes
TraversableLike → GenTraversableLike
def scanLeft[B, That](z: B)(op: (B, Param[N, E]) ⇒ B)(implicit bf: CanBuildFrom[This[N, E], B, That]): That

Definition Classes
TraversableLike → GenTraversableLike
def scanRight[B, That](z: B)(op: (Param[N, E], B) ⇒ B)(implicit bf: CanBuildFrom[This[N, E], B, That]): That

Definition Classes
TraversableLike → GenTraversableLike
Annotations
@migration
Migration
(Changed in version 2.9.0) The behavior of scanRight has changed. The previous behavior can be reproduced with scanRight.reverse.
def size: Int

Definition Classes
TraversableOnce → GenTraversableOnce
def sizeHintIfCheap: Int

Attributes
protected[scala.collection]
Definition Classes
GenTraversableOnce
def slice(from: Int, until: Int): This[N, E]

Definition Classes
IterableLike → TraversableLike → GenTraversableLike
def sliding(size: Int, step: Int): Iterator[This[N, E]]

Definition Classes
IterableLike
def sliding(size: Int): Iterator[This[N, E]]

Definition Classes
IterableLike
def span(p: (Param[N, E]) ⇒ Boolean): (This[N, E], This[N, E])

Definition Classes
TraversableLike → GenTraversableLike
def splitAt(n: Int): (This[N, E], This[N, E])

Definition Classes
TraversableLike → GenTraversableLike
def stringPrefix: String

Definition Classes
GraphLike → GraphLike → SetLike → TraversableLike → GenTraversableLike
def subsetOf(that: GenSet[Param[N, E]]): Boolean

Definition Classes
GenSetLike
def subsets(): Iterator[This[N, E]]

Definition Classes
SetLike
def subsets(len: Int): Iterator[This[N, E]]

Definition Classes
SetLike
def sum[B >: Param[N, E]](implicit num: Numeric[B]): B

Definition Classes
TraversableOnce → GenTraversableOnce
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def tail: This[N, E]

Definition Classes
TraversableLike → GenTraversableLike
def tails: Iterator[This[N, E]]

Definition Classes
TraversableLike
def take(n: Int): This[N, E]

Definition Classes
IterableLike → TraversableLike → GenTraversableLike
def takeRight(n: Int): This[N, E]

Definition Classes
IterableLike
def takeWhile(p: (Param[N, E]) ⇒ Boolean): This[N, E]

Definition Classes
IterableLike → TraversableLike → GenTraversableLike
def thisCollection: Iterable[Param[N, E]]

Attributes
protected[this]
Definition Classes
IterableLike → TraversableLike
def to[Col[_]](implicit cbf: CanBuildFrom[Nothing, Param[N, E], Col[Param[N, E]]]): Col[Param[N, E]]

Definition Classes
TraversableLike → TraversableOnce → GenTraversableOnce
def toArray[B >: Param[N, E]](implicit arg0: ClassTag[B]): Array[B]

Definition Classes
TraversableOnce → GenTraversableOnce
def toBuffer[A1 >: Param[N, E]]: Buffer[A1]

Definition Classes
SetLike → TraversableOnce → GenTraversableOnce
def toCollection(repr: This[N, E]): Iterable[Param[N, E]]

Attributes
protected[this]
Definition Classes
IterableLike → TraversableLike
def toIndexedSeq: IndexedSeq[Param[N, E]]

Definition Classes
TraversableOnce → GenTraversableOnce
def toIterable: Iterable[Param[N, E]]

Definition Classes
IterableLike → TraversableOnce → GenTraversableOnce
def toIterator: Iterator[Param[N, E]]

Definition Classes
IterableLike → TraversableLike → GenTraversableOnce
Annotations
@deprecatedOverriding( ... , "2.11.0" )
def toList: List[Param[N, E]]

Definition Classes
TraversableOnce → GenTraversableOnce
def toMap[T, U](implicit ev: <:<[Param[N, E], (T, U)]): Map[T, U]

Definition Classes
TraversableOnce → GenTraversableOnce
def toParArray: ParArray[T]

Implicit
This member is added by an implicit conversion from GraphLike[N, E, This] to CollectionsHaveToParArray[GraphLike[N, E, This], T] performed by method CollectionsHaveToParArray in scala.collection.parallel. This conversion will take place only if an implicit value of type (GraphLike[N, E, This]) ⇒ GenTraversableOnce[T] is in scope.
Definition Classes
CollectionsHaveToParArray
def toSeq: Seq[Param[N, E]]

Definition Classes
SetLike → TraversableOnce → GenTraversableOnce
def toSet[B >: Param[N, E]]: Set[B]

Definition Classes
TraversableOnce → GenTraversableOnce
def toSortedString(nodeSeparator: String, edgeSeparator: String, nodesEdgesSeparator: String, withNodesEdgesPrefix: Boolean)(implicit ordNode: (GraphLike.this)#NodeOrdering, ordEdge: (GraphLike.this)#EdgeOrdering): String

Definition Classes
GraphLike
def toStream: Stream[Param[N, E]]

Definition Classes
IterableLike → TraversableLike → GenTraversableOnce
def toString(): String

Definition Classes
GraphLike → SetLike → Function1 → TraversableLike → AnyRef → Any
def toTraversable: Traversable[Param[N, E]]

Definition Classes
TraversableLike → TraversableOnce → GenTraversableOnce
Annotations
@deprecatedOverriding( ... , "2.11.0" )
def toVector: Vector[Param[N, E]]

Definition Classes
TraversableOnce → GenTraversableOnce
final def topologicalSort[U](implicit visitor: ((GraphLike.this)#InnerElem) ⇒ U): (GraphLike.this)#CycleNodeOrTopologicalOrder

Definition Classes
GraphTraversal
final def topologicalSortByComponent[U](implicit visitor: ((GraphLike.this)#InnerElem) ⇒ U): Traversable[(GraphLike.this)#CycleNodeOrTopologicalOrder]

Definition Classes
GraphTraversal
def totalDegree(implicit nodeDegree: (GraphLike.this)#DegreeFunction, degreeFilter: (Int) ⇒ Boolean): Int

Definition Classes
GraphDegree
def totalWeight: Double

Definition Classes
GraphBase
def union(that: GenSet[Param[N, E]]): This[N, E]

Definition Classes
SetLike → GenSetLike
val value: GraphLike[N, E, This]

Implicit
This member is added by an implicit conversion from GraphLike[N, E, This] to OuterNode[GraphLike[N, E, This]] performed by method anyToNode in scalax.collection.GraphPredef.
Definition Classes
OuterNode → NodeParam
def view(from: Int, until: Int): IterableView[Param[N, E], This[N, E]]

Definition Classes
IterableLike → TraversableLike
def view: IterableView[Param[N, E], This[N, E]]

Definition Classes
IterableLike → TraversableLike
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
@native() @throws( ... )
def withFilter(p: (Param[N, E]) ⇒ Boolean): FilterMonadic[Param[N, E], This[N, E]]

Definition Classes
TraversableLike → FilterMonadic
final def withoutChecks[R](exec: ⇒ R): R

Attributes
protected
Definition Classes
GraphLike
def zip[A1 >: Param[N, E], B, That](that: GenIterable[B])(implicit bf: CanBuildFrom[This[N, E], (A1, B), That]): That

Definition Classes
IterableLike → GenIterableLike
def zipAll[B, A1 >: Param[N, E], That](that: GenIterable[B], thisElem: A1, thatElem: B)(implicit bf: CanBuildFrom[This[N, E], (A1, B), That]): That

Definition Classes
IterableLike → GenIterableLike
def zipWithIndex[A1 >: Param[N, E], That](implicit bf: CanBuildFrom[This[N, E], (A1, Int), That]): That

Definition Classes
IterableLike → GenIterableLike
def |(that: GenSet[Param[N, E]]): This[N, E]

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

Implicit
This member is added by an implicit conversion from GraphLike[N, E, This] to EdgeAssoc[GraphLike[N, E, This]] performed by method EdgeAssoc in scalax.collection.GraphPredef.
Definition Classes
EdgeAssoc
Annotations
@inline()
def ~>[N >: N1](n2: N): DiEdge[N]

Implicit
This member is added by an implicit conversion from GraphLike[N, E, This] to EdgeAssoc[GraphLike[N, E, This]] performed by method EdgeAssoc in scalax.collection.GraphPredef.
Definition Classes
EdgeAssoc
Annotations
@inline()
def →[B](y: B): (GraphLike[N, E, This], B)

Implicit
This member is added by an implicit conversion from GraphLike[N, E, This] to ArrowAssoc[GraphLike[N, E, This]] performed by method ArrowAssoc in scala.Predef.
Definition Classes
ArrowAssoc
object Edge extends Serializable

Definition Classes
GraphBase
Annotations
@transient()
object InnerEdge extends Serializable

Definition Classes
GraphBase
Annotations
@transient()
object InnerNode extends Serializable

Definition Classes
GraphBase
object Node extends Serializable

Definition Classes
GraphBase
Annotations
@transient()
object TraverserInnerNode extends Serializable

Definition Classes
GraphTraversal
Annotations
@transient()

Shadowed Implicit Value Members

def +(other: String): String
Implicit
This member is added by an implicit conversion from GraphLike[N, E, This] to any2stringadd[GraphLike[N, E, This]] performed by method any2stringadd in scala.Predef.
Shadowing
This implicitly inherited member is shadowed by one or more members in this class.
To access this member you can use a type ascription:
(graphLike: any2stringadd[GraphLike[N, E, This]]).+(other)
Definition Classes
any2stringadd
def andThen[A](g: (Boolean) ⇒ A): (Param[Param[N, E], EI]) ⇒ A
Implicit
This member is added by an implicit conversion from GraphLike[N, E, This] to (Param[Param[N, E], EI]) ⇒ Boolean performed by method predicateToNodePredicate in scalax.collection.GraphPredef.
Shadowing
This implicitly inherited member is shadowed by one or more members in this class.
To access this member you can use a type ascription:
(graphLike: (Param[Param[N, E], EI]) ⇒ Boolean).andThen(g)
Definition Classes
Function1
Annotations
@unspecialized()
def apply(v1: Param[Param[N, E], EI]): Boolean
Implicit
This member is added by an implicit conversion from GraphLike[N, E, This] to (Param[Param[N, E], EI]) ⇒ Boolean performed by method predicateToNodePredicate in scalax.collection.GraphPredef.
Shadowing
This implicitly inherited member is shadowed by one or more members in this class.
To access this member you can use a type ascription:
(graphLike: (Param[Param[N, E], EI]) ⇒ Boolean).apply(v1)
Definition Classes
Function1
def compose[A](g: (A) ⇒ Param[Param[N, E], EI]): (A) ⇒ Boolean
Implicit
This member is added by an implicit conversion from GraphLike[N, E, This] to (Param[Param[N, E], EI]) ⇒ Boolean performed by method predicateToNodePredicate in scalax.collection.GraphPredef.
Shadowing
This implicitly inherited member is shadowed by one or more members in this class.
To access this member you can use a type ascription:
(graphLike: (Param[Param[N, E], EI]) ⇒ Boolean).compose(g)
Definition Classes
Function1
Annotations
@unspecialized()
def filter(p: (Param[N, E]) ⇒ Boolean): TraversableOnce[Param[N, E]]
Implicit
This member is added by an implicit conversion from GraphLike[N, E, This] to MonadOps[Param[N, E]] performed by method MonadOps in scala.collection.TraversableOnce.
Shadowing
This implicitly inherited member is shadowed by one or more members in this class.
To access this member you can use a type ascription:
(graphLike: MonadOps[Param[N, E]]).filter(p)
Definition Classes
MonadOps
def flatMap[B](f: (Param[N, E]) ⇒ GenTraversableOnce[B]): TraversableOnce[B]
Implicit
This member is added by an implicit conversion from GraphLike[N, E, This] to MonadOps[Param[N, E]] performed by method MonadOps in scala.collection.TraversableOnce.
Shadowing
This implicitly inherited member is shadowed by one or more members in this class.
To access this member you can use a type ascription:
(graphLike: MonadOps[Param[N, E]]).flatMap(f)
Definition Classes
MonadOps
def map[B](f: (Param[N, E]) ⇒ B): TraversableOnce[B]
Implicit
This member is added by an implicit conversion from GraphLike[N, E, This] to MonadOps[Param[N, E]] performed by method MonadOps in scala.collection.TraversableOnce.
Shadowing
This implicitly inherited member is shadowed by one or more members in this class.
To access this member you can use a type ascription:
(graphLike: MonadOps[Param[N, E]]).map(f)
Definition Classes
MonadOps
def stringPrefix: String
Implicit
This member is added by an implicit conversion from GraphLike[N, E, This] to OuterNode[GraphLike[N, E, This]] performed by method anyToNode in scalax.collection.GraphPredef.
Shadowing
This implicitly inherited member is shadowed by one or more members in this class.
To access this member you can use a type ascription:
(graphLike: OuterNode[GraphLike[N, E, This]]).stringPrefix
Definition Classes
NodeParam
def toString(): String
Implicit
This member is added by an implicit conversion from GraphLike[N, E, This] to OuterNode[GraphLike[N, E, This]] performed by method anyToNode in scalax.collection.GraphPredef.
Shadowing
This implicitly inherited member is shadowed by one or more members in this class.
To access this member you can use a type ascription:
(graphLike: OuterNode[GraphLike[N, E, This]]).toString()
Definition Classes
NodeParam → AnyRef → Any
def toString(): String
Implicit
This member is added by an implicit conversion from GraphLike[N, E, This] to (Param[Param[N, E], EI]) ⇒ Boolean performed by method predicateToNodePredicate in scalax.collection.GraphPredef.
Shadowing
This implicitly inherited member is shadowed by one or more members in this class.
To access this member you can use a type ascription:
(graphLike: (Param[Param[N, E], EI]) ⇒ Boolean).toString()
Definition Classes
Function1 → AnyRef → Any
def withFilter(p: (Param[N, E]) ⇒ Boolean): Iterator[Param[N, E]]
Implicit
This member is added by an implicit conversion from GraphLike[N, E, This] to MonadOps[Param[N, E]] performed by method MonadOps in scala.collection.TraversableOnce.
Shadowing
This implicitly inherited member is shadowed by one or more members in this class.
To access this member you can use a type ascription:
(graphLike: MonadOps[Param[N, E]]).withFilter(p)
Definition Classes
MonadOps

Inherited from constrained.GraphLike[N, E, This]

Inherited from Constrained[N, E]

Inherited from ConstraintHandlerMethods[N, E]

Inherited from ConstraintMethods[N, E]

Inherited from mutable.GraphLike[N, E, This]

Inherited from Mutable

Inherited from EdgeOps[N, E, This]

Inherited from Cloneable[Graph[N, E]]

Inherited from Cloneable

Inherited from Shrinkable[Param[N, E]]

Packages

GraphLike 

trait GraphLike[N, E[X] <: EdgeLikeIn[X], +This[X, Y[X] <: EdgeLikeIn[X]] <: GraphLike[X, Y[X], This] with Graph[X, Y[X]]] extends mutable.GraphLike[N, E, This] with constrained.GraphLike[N, E, This] with Growable[Param[N, E]] with Shrinkable[Param[N, E]] with Cloneable[Graph[N, E]] with Mutable

Type Members

Abstract Value Members

Concrete Value Members

Shadowed Implicit Value Members

Inherited from constrained.GraphLike[N, E, This]

Inherited from Constrained[N, E]

Inherited from ConstraintHandlerMethods[N, E]

Inherited from ConstraintMethods[N, E]

Inherited from mutable.GraphLike[N, E, This]

Inherited from Mutable

Inherited from EdgeOps[N, E, This]

Inherited from Cloneable[Graph[N, E]]

Inherited from Cloneable

Inherited from Cloneable

Inherited from Shrinkable[Param[N, E]]

Inherited from Growable[Param[N, E]]

Inherited from Clearable

Inherited from collection.GraphLike[N, E, This]

Inherited from GraphDegree[N, E]

Inherited from GraphTraversal[N, E]

Inherited from GraphBase[N, E]

Inherited from Serializable

Inherited from Serializable

Inherited from SetLike[Param[N, E], This[N, E]]

Inherited from Subtractable[Param[N, E], This[N, E]]

Inherited from GenSetLike[Param[N, E], This[N, E]]

Inherited from (Param[N, E]) ⇒ Boolean

Inherited from IterableLike[Param[N, E], This[N, E]]

Inherited from GenIterableLike[Param[N, E], This[N, E]]

Inherited from TraversableLike[Param[N, E], This[N, E]]

Inherited from GenTraversableLike[Param[N, E], This[N, E]]

Inherited from Parallelizable[Param[N, E], ParSet[Param[N, E]]]

Inherited from TraversableOnce[Param[N, E]]

Inherited from GenTraversableOnce[Param[N, E]]

Inherited from FilterMonadic[Param[N, E], This[N, E]]

Inherited from HasNewBuilder[Param[N, E], This[N, E]]

Inherited from Equals

Inherited from AnyRef

Inherited from Any

Inherited by implicit conversion anyToNode from GraphLike[N, E, This] to OuterNode[GraphLike[N, E, This]]

Inherited by implicit conversion MonadOps from GraphLike[N, E, This] to MonadOps[Param[N, E]]

Inherited by implicit conversion CollectionsHaveToParArray from GraphLike[N, E, This] to CollectionsHaveToParArray[GraphLike[N, E, This], T]

Inherited by implicit conversion EdgeAssoc from GraphLike[N, E, This] to EdgeAssoc[GraphLike[N, E, This]]

Inherited by implicit conversion predicateToNodePredicate from GraphLike[N, E, This] to (Param[Param[N, E], EI]) ⇒ Boolean

Inherited by implicit conversion any2stringadd from GraphLike[N, E, This] to any2stringadd[GraphLike[N, E, This]]

Inherited by implicit conversion StringFormat from GraphLike[N, E, This] to StringFormat[GraphLike[N, E, This]]

Inherited by implicit conversion Ensuring from GraphLike[N, E, This] to Ensuring[GraphLike[N, E, This]]

Inherited by implicit conversion ArrowAssoc from GraphLike[N, E, This] to ArrowAssoc[GraphLike[N, E, This]]

Inherited by implicit conversion alternateImplicit from GraphLike[N, E, This] to ForceImplicitAmbiguity

Ungrouped

GraphLike