Packages

trait GraphOps[N, E <: Edge[N], +CC[X, Y <: Edge[X]]] extends OuterElems[N, E]

Operations common to mutable and immutable graphs.

Linear Supertypes
OuterElems[N, E], AnyRef, Any
Known Subclasses
AnyGraph, GraphBase, GraphLike, GraphTraversal, GraphTraversalImpl, AdjacencyListBase, AdjacencyListGraph, DefaultGraphImpl, Graph, AdjacencyListGraph, DefaultGraphImpl, Graph, GraphLike
Type Hierarchy
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. GraphOps
  2. OuterElems
  3. AnyRef
  4. Any
Implicitly
  1. by any2stringadd
  2. by StringFormat
  3. by Ensuring
  4. by ArrowAssoc
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Type Members

  1. type EdgePredicate = (EdgeT) => Boolean
  2. abstract type EdgeT <: InnerEdge
  3. trait InnerEdge extends InnerElem
  4. sealed trait InnerElem extends AnyRef
  5. trait InnerNode extends InnerElem
  6. type NodePredicate = (NodeT) => Boolean
  7. abstract type NodeT <: InnerNode
  8. sealed case class OuterEdge(edge: E) extends OuterElem with Product with Serializable

    To be mixed in by edge classes to allow passing them to Graph(...).

    To be mixed in by edge classes to allow passing them to Graph(...).

    Definition Classes
    OuterElems
  9. trait OuterElem extends AnyRef
    Definition Classes
    OuterElems
  10. sealed case class OuterNode(node: N) extends OuterElem with Product with Serializable

    Wraps any type to be accepted when calling Graph(...).

    Wraps any type to be accepted when calling Graph(...).

    Definition Classes
    OuterElems

Abstract Value Members

  1. abstract def anyEdge: EdgePredicate

    Edge predicate with constant true.

  2. abstract def anyNode: NodePredicate

    Node predicate with constant true.

  3. abstract def concat[N2 >: N, E2 >: E <: Edge[N2]](isolatedNodes: IterableOnce[N2], edges: IterableOnce[E2])(implicit e: <:<[E2, Edge[N2]]): CC[N2, E2]

    Creates a new graph by adding all edges and isolatedNodes omitting duplicates.

    Creates a new graph by adding all edges and isolatedNodes omitting duplicates. The new graph is upcasted if any of the arguments is an upcast of N respectively E. Use union to concatenate all nodes and edges of another graph.

    isolatedNodes

    to be concatenated. Nodes that are implicitly defined by any edge in edges will be ignored.

    edges

    to be concatenated.

  4. abstract def contains(edge: E): Boolean

    Whether the given outer edge is contained in this graph.

  5. abstract def contains(node: N): Boolean

    Whether the given outer node is contained in this graph.

  6. abstract def filter(nodeP: NodePredicate = anyNode, edgeP: EdgePredicate = anyEdge): CC[N, E]

    Computes a new graph with nodes satisfying nodeP and edges satisfying edgeP.

    Computes a new graph with nodes satisfying nodeP and edges satisfying edgeP. If both nodeP and edgeP have default values the original graph is retained.

  7. abstract def find(edge: E): Option[EdgeT]

    Searches this graph for an inner edge that wraps an outer edge equalling to the given outer edge.

  8. abstract def find(node: N): Option[NodeT]

    Searches this graph for an inner node that wraps an outer node equalling to the given outer node.

  9. abstract def flatMap[NN, EC[X] <: Edge[X]](fNode: (NodeT) => Seq[NN], fEdge: (EdgeT, Seq[NN], Seq[NN]) => Seq[EC[NN]])(implicit w: <:<[E, AnyEdge[N]]): CC[NN, EC[NN]]

    Creates a new graph with nodes and edges returned by fNode respectively fEdge.

    Creates a new graph with nodes and edges returned by fNode respectively fEdge.

    You can call this flavor only if this graph's edge type is generic. Otherwise see flatMapBound.

    NN

    The node type of the resulting graph which may be unchanged or different from this graph's node type.

    EC

    The higher kind of the generic edge type parameter of this graph.

    fNode

    To apply to all nodes of this graph. Since the inner node is passed you can also examine the node context. Call outer to get the value of type N of the node.

    fEdge

    To apply to all edges of this graph. This function is passed the current inner edge and its ends after being mapped by fNode. Since the inner edge is passed you can also examine its context. Call outer to get the outer edge of type E.

    returns

    A new graph of possibly changed node and edge types and of any new structure depending on your edge mapper(s).

  10. abstract def flatMap[NN, EC[X] <: Edge[X]](fNode: (NodeT) => Seq[NN])(implicit w1: <:<[E, GenericMapper], w2: =:=[EC[N], E], t: ClassTag[EC[NN]]): CC[NN, EC[NN]]

    Creates a new graph with nodes returned by fNode and an edge structure that remains intact where possible.

    Creates a new graph with nodes returned by fNode and an edge structure that remains intact where possible.

    You can call this flavor only if this graph's edge type is generic. Otherwise see flatMapBound.

    If this graph also contains typed edges, the typed edge's partial map function will be called to replace the ends. If the partial function is not defined, there will be an attempt to fall back to a generic edge. If that attempt also fails the edge will be dropped. So, if you have a mixed graph with generic and typed edges, prefer mapping edges directly to avoid leaving edges out.

    NN

    The node type of the resulting graph which may be unchanged or different from this graph's node type.

    EC

    The higher kind of the generic edge type parameter of this graph.

    fNode

    To apply to all nodes of this graph. Since the inner node is passed you can also examine the node context. Call outer to get the value of type N of the node. If fNode returns several new nodes with none equaling to the original node, the first new node is accepted to be the result of the node transformation. For more flexibility pass your own edge mapper to the overload.

    returns

    A new graph of possibly changed node and edge types and of any new structure depending on your edge mapper(s).

  11. abstract def flatMapBound[NN, EC <: Edge[NN]](fNode: (NodeT) => Seq[NN], fEdge: (EdgeT, Seq[NN], Seq[NN]) => Seq[EC])(implicit w: <:<[E, AnyEdge[N]]): CC[NN, EC]

    Creates a new graph with nodes and edges returned by fNode respectively fEdge.

    Creates a new graph with nodes and edges returned by fNode respectively fEdge.

    You can call this flavor only if this graph's edge type is typed. Otherwise see flatMap.

    NN

    The node type of the resulting graph which may be unchanged or different from this graph's node type.

    EC

    The edge type parameter of this graph.

    fNode

    To apply to all nodes of this graph. Since the inner node is passed you can also examine the node context. Call outer to get the value of type N of the node.

    fEdge

    To apply to all edges of this graph. This function is passed the current inner edge and its ends after being mapped by fNode. Since the inner edge is passed you can also examine its context. Call outer to get the outer edge of type E.

    returns

    A new graph of possibly changed node and edge types and of any new structure depending on your edge mapper(s).

  12. abstract def flatMapBound(fNode: (NodeT) => Seq[N])(implicit w1: <:<[E, PartialMapper]): CC[N, E]

    Creates a new graph with nodes returned by fNode and an edge structure that remains intact where possible.

    Creates a new graph with nodes returned by fNode and an edge structure that remains intact where possible.

    You can call this flavor only if this graph's edge type is typed. Otherwise see flatMap.

    fNode

    To apply to all nodes of this graph. Since the inner node is passed you can also examine the node context. Call outer to get the value of type N of the node. If fNode returns several new nodes with none equaling to the original node, the first new node is accepted to be the result of the node transformation. For more flexibility pass your own edge mapper to the overload.

  13. abstract def flatMapDiHyper[NN, EC[X] <: Edge[X]](fNode: (NodeT) => Seq[NN], fDiHyperEdge: (EdgeT, Seq[NN], Seq[NN]) => Seq[EC[NN]], fEdge: Option[(EdgeT, Seq[NN], Seq[NN]) => Seq[EC[NN]]])(implicit w: <:<[E, AnyDiHyperEdge[N]]): CC[NN, EC[NN]]

    Creates a new graph with nodes and edges returned by fNode respectively fEdge.

    Creates a new graph with nodes and edges returned by fNode respectively fEdge.

    You can call this flavor only if this graph's edge type is generic. Otherwise see flatMapDiHyperBound.

    NN

    The node type of the resulting graph which may be unchanged or different from this graph's node type.

    EC

    The higher kind of the generic edge type parameter of this graph.

    fNode

    To apply to all nodes of this graph. Since the inner node is passed you can also examine the node context. Call outer to get the value of type N of the node.

    fDiHyperEdge

    To apply to all directed hyperedges in this graph. This function is passed the existing inner directed hyperedge and its sources and targets after being mapped by fNode. Since the inner directed hyperedge is passed you can also examine the edge context. Call outer to get the outer directed hyperedge of type E.

    fEdge

    To apply to any directed or undirected edge in this possibly mixed graph. If not present simple edges will be mapped by the mandatory edge mapper you supply. You are recommended supplying Some unless you know that the graph does not contain any simple edge.

    returns

    A new graph of possibly changed node and edge types and of any new structure depending on your edge mapper(s).

  14. abstract def flatMapDiHyperBound[NN, EC <: Edge[NN]](fNode: (NodeT) => Seq[NN], fDiHyperEdge: (EdgeT, Seq[NN], Seq[NN]) => Seq[EC], fEdge: Option[(EdgeT, Seq[NN], Seq[NN]) => Seq[EC]])(implicit w: <:<[E, AnyDiHyperEdge[N]]): CC[NN, EC]

    Creates a new graph with nodes and edges returned by fNode respectively fEdge.

    Creates a new graph with nodes and edges returned by fNode respectively fEdge.

    You can call this flavor only if this graph's edge type is typed. Otherwise see flatMapDiHyper.

    NN

    The node type of the resulting graph which may be unchanged or different from this graph's node type.

    EC

    The edge type parameter of this graph.

    fNode

    To apply to all nodes of this graph. Since the inner node is passed you can also examine the node context. Call outer to get the value of type N of the node.

    fDiHyperEdge

    To apply to all directed hyperedges in this graph. This function is passed the existing inner directed hyperedge and its sources and targets after being mapped by fNode. Since the inner directed hyperedge is passed you can also examine the edge context. Call outer to get the outer directed hyperedge of type E.

    fEdge

    To apply to any directed or undirected edge in this possibly mixed graph. If not present simple edges will be mapped by the mandatory edge mapper you supply. You are recommended supplying Some unless you know that the graph does not contain any simple edge.

    returns

    A new graph of possibly changed node and edge types and of any new structure depending on your edge mapper(s).

  15. abstract def flatMapHyper[NN, EC[X] <: Edge[X]](fNode: (NodeT) => Seq[NN], fHyperEdge: (EdgeT, Seq[NN]) => Seq[EC[NN]], fDiHyperEdge: Option[(EdgeT, Seq[NN], Seq[NN]) => Seq[EC[NN]]], fEdge: Option[(EdgeT, Seq[NN], Seq[NN]) => Seq[EC[NN]]])(implicit w: <:<[E, AnyHyperEdge[N]]): CC[NN, EC[NN]]

    Creates a new graph with nodes and edges returned by fNode respectively fEdge.

    Creates a new graph with nodes and edges returned by fNode respectively fEdge.

    You can call this flavor only if this graph's edge type is generic. Otherwise see flatMapHyperBound.

    NN

    The node type of the resulting graph which may be unchanged or different from this graph's node type.

    EC

    The higher kind of the generic edge type parameter of this graph.

    fNode

    To apply to all nodes of this graph. Since the inner node is passed you can also examine the node context. Call outer to get the value of type N of the node.

    fHyperEdge

    To apply to all hyperedges in this graph. This function is passed the current inner hyperedge and its ends after being mapped by fNode. Since the inner hyperedge is passed you can also examine its context. Call outer to get the outer hyperedge of type E.

    fDiHyperEdge

    To apply to any directed hyperedge in this possibly mixed graph. If not present directed hyperedges will be mapped by the mandatory fDiHyperEdge. You are recommended supplying Some unless you know that the graph does not contain any directed hyperedge.

    fEdge

    To apply to any directed or undirected edge in this possibly mixed graph. If not present simple edges will be mapped by the mandatory edge mapper you supply. You are recommended supplying Some unless you know that the graph does not contain any simple edge.

    returns

    A new graph of possibly changed node and edge types and of any new structure depending on your edge mapper(s).

  16. abstract def flatMapHyperBound[NN, EC <: Edge[NN]](fNode: (NodeT) => Seq[NN], fHyperEdge: (EdgeT, Seq[NN]) => Seq[EC], fDiHyperEdge: Option[(EdgeT, Seq[NN], Seq[NN]) => Seq[EC]], fEdge: Option[(EdgeT, Seq[NN], Seq[NN]) => Seq[EC]])(implicit w: <:<[E, AnyHyperEdge[N]]): CC[NN, EC]

    Creates a new graph with nodes and edges returned by fNode respectively fEdge.

    Creates a new graph with nodes and edges returned by fNode respectively fEdge.

    You can call this flavor only if this graph's edge type is typed. Otherwise see flatMapHyper.

    NN

    The node type of the resulting graph which may be unchanged or different from this graph's node type.

    EC

    The edge type parameter of this graph.

    fNode

    To apply to all nodes of this graph. Since the inner node is passed you can also examine the node context. Call outer to get the value of type N of the node.

    fHyperEdge

    To apply to all hyperedges in this graph. This function is passed the current inner hyperedge and its ends after being mapped by fNode. Since the inner hyperedge is passed you can also examine its context. Call outer to get the outer hyperedge of type E.

    fDiHyperEdge

    To apply to any directed hyperedge in this possibly mixed graph. If not present directed hyperedges will be mapped by the mandatory fDiHyperEdge. You are recommended supplying Some unless you know that the graph does not contain any directed hyperedge.

    fEdge

    To apply to any directed or undirected edge in this possibly mixed graph. If not present simple edges will be mapped by the mandatory edge mapper you supply. You are recommended supplying Some unless you know that the graph does not contain any simple edge.

    returns

    A new graph of possibly changed node and edge types and of any new structure depending on your edge mapper(s).

  17. abstract def foldLeft[B](z: B)(opNode: (B, NodeT) => B, opEdge: (B, EdgeT) => B): B

    Applies a node-specific and an edge-specific binary operator to a cumulated value.

    Applies a node-specific and an edge-specific binary operator to a cumulated value. First opNode is called for all nodes than opEdge for all edges.

    B

    the result type of the binary operator.

    z

    the start value that is passed to opNode the first time.

    opNode

    the binary operator that is passed the cumulated value and an inner node.

    opEdge

    the binary operator that is passed the cumulated value and an inner edge.

    returns

    the cumulated value.

  18. abstract def get(edge: E): EdgeT

    Short for find(edge).get.

    Short for find(edge).get.

    Exceptions thrown

    NoSuchElementException if the edge is not found.

  19. abstract def get(node: N): NodeT

    Short for find(node).get.

    Short for find(node).get.

    Exceptions thrown

    NoSuchElementException if the node is not found.

  20. abstract def isDirected: Boolean

    Whether all edges of this graph are directed.

  21. abstract def isHyper: Boolean

    Whether this graph contains at least one hyperedge.

  22. abstract def isMixed: Boolean

    Whether this graph contains at least one directed and one undirected edge.

  23. abstract def isMulti: Boolean

    Whether this graph contains at least one multi-edge.

    Whether this graph contains at least one multi-edge. We defnie multi-edges by

    1. two or more directed edges having the same source and target
    2. two or more undirected edges connecting the same nodes
    3. two or more (directed) hyperedges that, after being decomposed into (directed) edges, yield any multy-edge as stipulated above.
  24. abstract def iterator: Iterator[InnerElem]

    Iterator over all inner nodes and edges.

  25. abstract def map[NN, EC[X] <: Edge[X]](fNode: (NodeT) => NN, fEdge: (EdgeT, NN, NN) => EC[NN])(implicit w: <:<[E, AnyEdge[N]]): CC[NN, EC[NN]]

    Creates a new graph with nodes and edges that are computed by the supplied mapping functions.

    Creates a new graph with nodes and edges that are computed by the supplied mapping functions.

    You can call this flavor only if this graph's edge type is generic. Otherwise see mapBound.

    NN

    The node type of the resulting graph which may be unchanged or different from this graph's node type.

    EC

    The higher kind of the generic edge type parameter of this graph.

    fNode

    To apply to all nodes of this graph. Since the inner node is passed you can also examine the node context. Call outer to get the value of type N of the node.

    fEdge

    To apply to all edges of this graph. This function is passed the current inner edge and its ends after being mapped by fNode. Since the inner edge is passed you can also examine its context. Call outer to get the outer edge of type E.

    returns

    The mapped graph with possibly changed node and edge type parameters.

  26. abstract def map[NN, EC[X] <: Edge[X]](fNode: (NodeT) => NN)(implicit w1: <:<[E, GenericMapper], w2: =:=[EC[N], E], t: ClassTag[EC[NN]]): CC[NN, EC[NN]]

    Creates a new graph with nodes mapped by fNode and with an untouched edge structure otherwise.

    Creates a new graph with nodes mapped by fNode and with an untouched edge structure otherwise.

    You can call this flavor only if this graph's edge type is generic. Otherwise see mapBound.

    If this graph also contains typed edges, the typed edge's partial map function will be called to replace the ends. If the partial function is not defined, there will be an attempt to fall back to a generic edge. If that attempt also fails the edge will be dropped. So, if you have a mixed graph with generic and typed edges, prefer mapping edges directly to avoid leaving edges out.

    NN

    The node type of the resulting graph which may be unchanged or different from this graph's node type.

    EC

    The higher kind of the generic edge type parameter of this graph.

    fNode

    To apply to all nodes of this graph. Since the inner node is passed you can also examine the node context. Call outer to get the value of type N of the node.

    returns

    The mapped graph with possibly changed node and edge type parameters.

  27. abstract def mapBound[NN, EC <: Edge[NN]](fNode: (NodeT) => NN, fEdge: (EdgeT, NN, NN) => EC)(implicit w: <:<[E, AnyEdge[N]]): CC[NN, EC]

    Creates a new graph with nodes and edges that are computed by the supplied mapping functions.

    Creates a new graph with nodes and edges that are computed by the supplied mapping functions.

    You can call this flavor only if this graph's edge type is typed. Otherwise see map.

    NN

    The node type of the resulting graph which may be unchanged or different from this graph's node type.

    EC

    The edge type parameter of this graph.

    fNode

    To apply to all nodes of this graph. Since the inner node is passed you can also examine the node context. Call outer to get the value of type N of the node.

    fEdge

    To apply to all edges of this graph. This function is passed the current inner edge and its ends after being mapped by fNode. Since the inner edge is passed you can also examine its context. Call outer to get the outer edge of type E.

    returns

    The mapped graph with possibly changed node and edge type parameters.

  28. abstract def mapBound(fNode: (NodeT) => N)(implicit w1: <:<[E, PartialMapper]): CC[N, E]

    Creates a new graph with nodes mapped by fNode and with an untouched edge structure otherwise.

    Creates a new graph with nodes mapped by fNode and with an untouched edge structure otherwise.

    You can call this flavor only if this graph's edge type is typed. Otherwise see map.

    fNode

    To apply to all nodes of this graph. Since the inner node is passed you can also examine the node context. Call outer to get the value of type N of the node.

    returns

    The mapped graph with possibly changed node and edge type parameters.

  29. abstract def mapDiHyper[NN, EC[X] <: Edge[X]](fNode: (NodeT) => NN, fDiHyperEdge: (EdgeT, OneOrMore[NN], OneOrMore[NN]) => EC[NN], fEdge: Option[(EdgeT, NN, NN) => EC[NN]])(implicit w: <:<[E, AnyDiHyperEdge[N]]): CC[NN, EC[NN]]

    Creates a new graph with nodes and edges that are computed by the supplied mapping functions.

    Creates a new graph with nodes and edges that are computed by the supplied mapping functions.

    You can call this flavor only if this graph's edge type is generic. Otherwise see mapDiHyperBound.

    NN

    The node type of the resulting graph which may be unchanged or different from this graph's node type.

    EC

    The higher kind of the generic edge type parameter of this graph.

    fNode

    To apply to all nodes of this graph. Since the inner node is passed you can also examine the node context. Call outer to get the value of type N of the node.

    fDiHyperEdge

    To apply to all directed hyperedges in this graph. This function is passed the existing inner directed hyperedge and its sources and targets after being mapped by fNode. Since the inner directed hyperedge is passed you can also examine the edge context. Call outer to get the outer directed hyperedge of type E.

    fEdge

    To apply to any directed or undirected edge in this possibly mixed graph. If not present simple edges will be mapped by the mandatory edge mapper you supply. You are recommended supplying Some unless you know that the graph does not contain any simple edge.

    returns

    The mapped graph with possibly changed node and edge type parameters.

  30. abstract def mapDiHyperBound[NN, EC <: Edge[NN]](fNode: (NodeT) => NN, fDiHyperEdge: (EdgeT, OneOrMore[NN], OneOrMore[NN]) => EC, fEdge: Option[(EdgeT, NN, NN) => EC])(implicit w: <:<[E, AnyDiHyperEdge[N]]): CC[NN, EC]

    Creates a new graph with nodes and edges that are computed by the supplied mapping functions.

    Creates a new graph with nodes and edges that are computed by the supplied mapping functions.

    You can call this flavor only if this graph's edge type is typed. Otherwise see mapDiHyper.

    NN

    The node type of the resulting graph which may be unchanged or different from this graph's node type.

    EC

    The edge type parameter of this graph.

    fNode

    To apply to all nodes of this graph. Since the inner node is passed you can also examine the node context. Call outer to get the value of type N of the node.

    fDiHyperEdge

    To apply to all directed hyperedges in this graph. This function is passed the existing inner directed hyperedge and its sources and targets after being mapped by fNode. Since the inner directed hyperedge is passed you can also examine the edge context. Call outer to get the outer directed hyperedge of type E.

    fEdge

    To apply to any directed or undirected edge in this possibly mixed graph. If not present simple edges will be mapped by the mandatory edge mapper you supply. You are recommended supplying Some unless you know that the graph does not contain any simple edge.

    returns

    The mapped graph with possibly changed node and edge type parameters.

  31. abstract def mapHyper[NN, EC[X] <: Edge[X]](fNode: (NodeT) => NN, fHyperEdge: (EdgeT, Several[NN]) => EC[NN], fDiHyperEdge: Option[(EdgeT, OneOrMore[NN], OneOrMore[NN]) => EC[NN]], fEdge: Option[(EdgeT, NN, NN) => EC[NN]])(implicit w: <:<[E, AnyHyperEdge[N]]): CC[NN, EC[NN]]

    Creates a new graph with nodes and edges that are computed by the supplied mapping functions.

    Creates a new graph with nodes and edges that are computed by the supplied mapping functions.

    You can call this flavor only if this graph's edge type is generic. Otherwise see mapHyperBound.

    NN

    The node type of the resulting graph which may be unchanged or different from this graph's node type.

    EC

    The higher kind of the generic edge type parameter of this graph.

    fNode

    To apply to all nodes of this graph. Since the inner node is passed you can also examine the node context. Call outer to get the value of type N of the node.

    fHyperEdge

    To apply to all hyperedges in this graph. This function is passed the current inner hyperedge and its ends after being mapped by fNode. Since the inner hyperedge is passed you can also examine its context. Call outer to get the outer hyperedge of type E.

    fDiHyperEdge

    To apply to any directed hyperedge in this possibly mixed graph. If not present directed hyperedges will be mapped by the mandatory fDiHyperEdge. You are recommended supplying Some unless you know that the graph does not contain any directed hyperedge.

    fEdge

    To apply to any directed or undirected edge in this possibly mixed graph. If not present simple edges will be mapped by the mandatory edge mapper you supply. You are recommended supplying Some unless you know that the graph does not contain any simple edge.

    returns

    The mapped graph with possibly changed node and edge type parameters.

  32. abstract def mapHyperBound[NN, EC <: Edge[NN]](fNode: (NodeT) => NN, fHyperEdge: (EdgeT, Several[NN]) => EC, fDiHyperEdge: Option[(EdgeT, OneOrMore[NN], OneOrMore[NN]) => EC], fEdge: Option[(EdgeT, NN, NN) => EC])(implicit w: <:<[E, AnyHyperEdge[N]]): CC[NN, EC]

    Creates a new graph with nodes and edges that are computed by the supplied mapping functions.

    Creates a new graph with nodes and edges that are computed by the supplied mapping functions.

    You can call this flavor only if this graph's edge type is typed. Otherwise see mapHyper.

    NN

    The node type of the resulting graph which may be unchanged or different from this graph's node type.

    EC

    The edge type parameter of this graph.

    fNode

    To apply to all nodes of this graph. Since the inner node is passed you can also examine the node context. Call outer to get the value of type N of the node.

    fHyperEdge

    To apply to all hyperedges in this graph. This function is passed the current inner hyperedge and its ends after being mapped by fNode. Since the inner hyperedge is passed you can also examine its context. Call outer to get the outer hyperedge of type E.

    fDiHyperEdge

    To apply to any directed hyperedge in this possibly mixed graph. If not present directed hyperedges will be mapped by the mandatory fDiHyperEdge. You are recommended supplying Some unless you know that the graph does not contain any directed hyperedge.

    fEdge

    To apply to any directed or undirected edge in this possibly mixed graph. If not present simple edges will be mapped by the mandatory edge mapper you supply. You are recommended supplying Some unless you know that the graph does not contain any simple edge.

    returns

    The mapped graph with possibly changed node and edge type parameters.

  33. abstract def noEdge: EdgePredicate

    Edge predicate with constant false.

  34. abstract def noNode: NodePredicate

    Node predicate with constant false.

  35. abstract def order: Int

    The order, commonly referred to as |G|, of this graph equaling to the number of nodes.

  36. abstract def outerIterator: Iterator[OuterElem]

    Iterator over all inner nodes and edges.

  37. abstract def removedAll(isolatedNodes: IterableOnce[N], edges: IterableOnce[E]): CC[N, E]
    Attributes
    protected
  38. abstract def size: Int

    The size, commonly referred to as ||G||, of this graph equaling to the number of edges.

  39. abstract def toIterable: Iterable[InnerElem]

    Iterable over all nodes and edges.

  40. abstract def toOuterIterable: Iterable[OuterElem]

    Iterable over all nodes and edges.

  41. abstract def totalWeight: Double

    The Sum of the weight of all edges.

Concrete Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##: Int
    Definition Classes
    AnyRef → Any
  3. final def &(that: AnyGraph[N, E]): CC[N, E]

    Alias for intersect.

    Alias for intersect.

    Annotations
    @inline()
  4. final def &~(that: AnyGraph[N, E]): CC[N, E]

    Alias for diff.

    Alias for diff.

    Annotations
    @inline()
  5. def +(other: String): String
    Implicit
    This member is added by an implicit conversion from GraphOps[N, E, CC] toany2stringadd[GraphOps[N, E, CC]] performed by method any2stringadd in scala.Predef.
    Definition Classes
    any2stringadd
  6. final def ++[N2 >: N, E2 >: E <: Edge[N2]](edges: IterableOnce[E2])(implicit e: <:<[E2, Edge[N2]]): CC[N2, E2]

    Alias for concat(edges).

    Alias for concat(edges).

    Annotations
    @inline()
  7. final def ++[N2 >: N, E2 >: E <: Edge[N2]](isolatedNodes: IterableOnce[N2], edges: IterableOnce[E2])(implicit e: <:<[E2, Edge[N2]]): CC[N2, E2]

    Alias for concat(isolatedNodes, edges).

    Alias for concat(isolatedNodes, edges).

    Annotations
    @inline()
  8. def ->[B](y: B): (GraphOps[N, E, CC], B)
    Implicit
    This member is added by an implicit conversion from GraphOps[N, E, CC] toArrowAssoc[GraphOps[N, E, CC]] performed by method ArrowAssoc in scala.Predef.
    Definition Classes
    ArrowAssoc
    Annotations
    @inline()
  9. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  10. final def apply(edge: E): Boolean

    Whether the given edge is contained in this graph.

    Whether the given edge is contained in this graph.

    Annotations
    @inline()
  11. final def apply(node: N): Boolean

    Whether the given node is contained in this graph.

    Whether the given node is contained in this graph.

    Annotations
    @inline()
  12. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  13. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @native() @HotSpotIntrinsicCandidate()
  14. def concat[N2 >: N, E2 >: E <: Edge[N2]](edges: IterableOnce[E2])(implicit e: <:<[E2, Edge[N2]]): CC[N2, E2]

    Same as concat(isolatedNodes, edges) but with empty isolatedNodes.

    Same as concat(isolatedNodes, edges) but with empty isolatedNodes. This method is useful if you don't need to pass any isolated node.

  15. final def diff(that: AnyGraph[N, E]): CC[N, E]

    Computes a new graph that is the difference of this graph and that graph.

  16. final def elementCount: Int

    The number of nodes and edges.

    The number of nodes and edges.

    Annotations
    @inline()
  17. def ensuring(cond: (GraphOps[N, E, CC]) => Boolean, msg: => Any): GraphOps[N, E, CC]
    Implicit
    This member is added by an implicit conversion from GraphOps[N, E, CC] toEnsuring[GraphOps[N, E, CC]] performed by method Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  18. def ensuring(cond: (GraphOps[N, E, CC]) => Boolean): GraphOps[N, E, CC]
    Implicit
    This member is added by an implicit conversion from GraphOps[N, E, CC] toEnsuring[GraphOps[N, E, CC]] performed by method Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  19. def ensuring(cond: Boolean, msg: => Any): GraphOps[N, E, CC]
    Implicit
    This member is added by an implicit conversion from GraphOps[N, E, CC] toEnsuring[GraphOps[N, E, CC]] performed by method Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  20. def ensuring(cond: Boolean): GraphOps[N, E, CC]
    Implicit
    This member is added by an implicit conversion from GraphOps[N, E, CC] toEnsuring[GraphOps[N, E, CC]] performed by method Ensuring in scala.Predef.
    Definition Classes
    Ensuring
  21. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  22. def equals(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef → Any
  23. def filterNot(nodeP: NodePredicate = noNode, edgeP: EdgePredicate = noEdge): CC[N, E]

    Computes a new graph without nodes satisfying nodeP and without edges satisfying ePred.

    Computes a new graph without nodes satisfying nodeP and without edges satisfying ePred. If both nodeP and ePred have default values the original graph is retained.

  24. final def flatMap[NN, EC[X] <: Edge[X]](fNode: (NodeT) => Seq[NN], fEdge: (Seq[NN], Seq[NN]) => Seq[EC[NN]])(implicit w: <:<[E, AnyEdge[N]]): CC[NN, EC[NN]]

    Creates a new graph with nodes and edges returned by fNode respectively fEdge.

    Creates a new graph with nodes and edges returned by fNode respectively fEdge.

    See overload except the parameter

    fEdge

    has a simplified signature in this overload leaving out the inner edge. This comes in handy whenever you don't need to inspect inner edges.

  25. final def flatMapBound[NN, EC <: Edge[NN]](fNode: (NodeT) => Seq[NN], fEdge: (Seq[NN], Seq[NN]) => Seq[EC])(implicit w: <:<[E, AnyEdge[N]]): CC[NN, EC]

    Creates a new graph with nodes and edges returned by fNode respectively fEdge.

    Creates a new graph with nodes and edges returned by fNode respectively fEdge.

    You can call this flavor only if this graph's edge type is typed. Otherwise see flatMap.

    See overload except the parameter

    fEdge

    has a simplified signature in this overload leaving out the inner edge. This comes in handy whenever you don't need to inspect inner edges.

  26. final def flatMapDiHyper[NN, EC[X] <: Edge[X]](fNode: (NodeT) => Seq[NN], fDiHyperEdge: (Seq[NN], Seq[NN]) => Seq[EC[NN]], fEdge: Option[(Seq[NN], Seq[NN]) => Seq[EC[NN]]] = None)(implicit w: <:<[E, AnyDiHyperEdge[N]]): CC[NN, EC[NN]]

    Creates a new graph with nodes and edges returned by fNode respectively fEdge.

    Creates a new graph with nodes and edges returned by fNode respectively fEdge.

    You can call this flavor only if this graph's edge type is generic. Otherwise see flatMapDiHyperBound.

    See overload except the parameter

    fDiHyperEdge

    has a simplified signature in this overload leaving out the inner edge. This comes in handy whenever you don't need to inspect inner edges.

  27. final def flatMapDiHyperBound[NN, EC <: Edge[NN]](fNode: (NodeT) => Seq[NN], fDiHyperEdge: (Seq[NN], Seq[NN]) => Seq[EC], fEdge: Option[(Seq[NN], Seq[NN]) => Seq[EC]] = None)(implicit w: <:<[E, AnyDiHyperEdge[N]]): CC[NN, EC]

    Creates a new graph with nodes and edges returned by fNode respectively fEdge.

    Creates a new graph with nodes and edges returned by fNode respectively fEdge.

    You can call this flavor only if this graph's edge type is typed. Otherwise see flatMapDiHyper.

    See overload except the parameter

    fDiHyperEdge

    has a simplified signature in this overload leaving out the inner edge. This comes in handy whenever you don't need to inspect inner edges.

  28. final def flatMapHyper[NN, EC[X] <: Edge[X]](fNode: (NodeT) => Seq[NN], fHyperEdge: (Seq[NN]) => Seq[EC[NN]], fDiHyperEdge: Option[(Seq[NN], Seq[NN]) => Seq[EC[NN]]] = None, fEdge: Option[(Seq[NN], Seq[NN]) => Seq[EC[NN]]] = None)(implicit w: <:<[E, AnyHyperEdge[N]]): CC[NN, EC[NN]]

    Creates a new graph with nodes and edges returned by fNode respectively fEdge.

    Creates a new graph with nodes and edges returned by fNode respectively fEdge.

    You can call this flavor only if this graph's edge type is generic. Otherwise see flatMapHyperBound.

    See overload except the parameter

    fHyperEdge

    has a simplified signature in this overload leaving out the inner edge. This comes in handy whenever you don't need to inspect inner edges.

  29. final def flatMapHyperBound[NN, EC <: Edge[NN]](fNode: (NodeT) => Seq[NN], fHyperEdge: (Seq[NN]) => Seq[EC], fDiHyperEdge: Option[(Seq[NN], Seq[NN]) => Seq[EC]] = None, fEdge: Option[(Seq[NN], Seq[NN]) => Seq[EC]] = None)(implicit w: <:<[E, AnyHyperEdge[N]]): CC[NN, EC]

    Creates a new graph with nodes and edges returned by fNode respectively fEdge.

    Creates a new graph with nodes and edges returned by fNode respectively fEdge.

    You can call this flavor only if this graph's edge type is typed. Otherwise see flatMapHyper.

    See overload except the parameter

    fHyperEdge

    has a simplified signature in this overload leaving out the inner edge. This comes in handy whenever you don't need to inspect inner edges.

  30. final def foldLeftOuter[B](z: B)(opNode: (B, N) => B, opEdge: (B, E) => B): B

    Same as foldLeft except the second parameter of the binary operators.

    Same as foldLeft except the second parameter of the binary operators.

    opNode

    the binary operator that is passed the cumulated value and an outer node.

    opEdge

    the binary operator that is passed the cumulated value and an outer edge.

  31. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  32. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  33. final def intersect(that: AnyGraph[N, E]): CC[N, E]

    Computes the intersection between this graph and that graph.

  34. final def isEmpty: Boolean

    Whether this graph contains any node or any edge.

    Whether this graph contains any node or any edge.

    Annotations
    @inline()
  35. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  36. final def isTrivial: Boolean

    true if this graph has at most 1 node.

    true if this graph has at most 1 node.

    Annotations
    @inline()
  37. final def map[NN, EC[X] <: Edge[X]](fNode: (NodeT) => NN, fEdge: (NN, NN) => EC[NN])(implicit w: <:<[E, AnyEdge[N]]): CC[NN, EC[NN]]

    Creates a new graph with nodes and edges that are computed by the supplied mapping functions.

    Creates a new graph with nodes and edges that are computed by the supplied mapping functions.

    See overload except the parameter

    fEdge

    has a simplified signature in this overload leaving out the inner edge. This comes in handy whenever you don't need to inspect inner edges.

  38. final def mapBound[NN, EC <: Edge[NN]](fNode: (NodeT) => NN, fEdge: (NN, NN) => EC)(implicit w: <:<[E, AnyEdge[N]]): CC[NN, EC]

    Creates a new graph with nodes and edges that are computed by the supplied mapping functions.

    Creates a new graph with nodes and edges that are computed by the supplied mapping functions.

    See overload except the parameter

    fEdge

    has a simplified signature in this overload leaving out the inner edge. This comes in handy whenever you don't need to inspect inner edges.

  39. final def mapDiHyper[NN, EC[X] <: Edge[X]](fNode: (NodeT) => NN, fDiHyperEdge: (OneOrMore[NN], OneOrMore[NN]) => EC[NN], fEdge: Option[(NN, NN) => EC[NN]] = None)(implicit w: <:<[E, AnyDiHyperEdge[N]]): CC[NN, EC[NN]]

    Creates a new graph with nodes and edges that are computed by the supplied mapping functions.

    Creates a new graph with nodes and edges that are computed by the supplied mapping functions.

    You can call this flavor only if this graph's edge type is generic. Otherwise see mapDiHyperBound.

    See overload except the parameter

    fDiHyperEdge

    has a simplified signature in this overload leaving out the inner edge. This comes in handy whenever you don't need to inspect inner edges.

  40. final def mapDiHyperBound[NN, EC <: Edge[NN]](fNode: (NodeT) => NN, fDiHyperEdge: (OneOrMore[NN], OneOrMore[NN]) => EC, fEdge: Option[(NN, NN) => EC] = None)(implicit w: <:<[E, AnyDiHyperEdge[N]]): CC[NN, EC]

    Creates a new graph with nodes and edges that are computed by the supplied mapping functions.

    Creates a new graph with nodes and edges that are computed by the supplied mapping functions.

    You can call this flavor only if this graph's edge type is typed. Otherwise see mapDiHyper.

    See overload except the parameter

    fDiHyperEdge

    has a simplified signature in this overload leaving out the inner edge. This comes in handy whenever you don't need to inspect inner edges.

  41. final def mapHyper[NN, EC[X] <: Edge[X]](fNode: (NodeT) => NN, fHyperEdge: (Several[NN]) => EC[NN], fDiHyperEdge: Option[(OneOrMore[NN], OneOrMore[NN]) => EC[NN]] = None, fEdge: Option[(NN, NN) => EC[NN]] = None)(implicit w: <:<[E, AnyHyperEdge[N]]): CC[NN, EC[NN]]

    Creates a new graph with nodes and edges that are computed by the supplied mapping functions.

    Creates a new graph with nodes and edges that are computed by the supplied mapping functions.

    You can call this flavor only if this graph's edge type is generic. Otherwise see mapHyperBound.

    See overload except the parameter

    fHyperEdge

    has a simplified signature in this overload leaving out the inner edge. This comes in handy whenever you don't need to inspect inner edges.

  42. final def mapHyperBound[NN, EC <: Edge[NN]](fNode: (NodeT) => NN, fHyperEdge: (Several[NN]) => EC, fDiHyperEdge: Option[(OneOrMore[NN], OneOrMore[NN]) => EC] = None, fEdge: Option[(NN, NN) => EC] = None)(implicit w: <:<[E, AnyHyperEdge[N]]): CC[NN, EC]

    Creates a new graph with nodes and edges that are computed by the supplied mapping functions.

    Creates a new graph with nodes and edges that are computed by the supplied mapping functions.

    You can call this flavor only if this graph's edge type is typed. Otherwise see mapHyper.

    See overload except the parameter

    fHyperEdge

    has a simplified signature in this overload leaving out the inner edge. This comes in handy whenever you don't need to inspect inner edges.

  43. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  44. final def nonTrivial: Boolean

    true if this graph has at least 2 nodes.

    true if this graph has at least 2 nodes.

    Annotations
    @inline()
  45. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  46. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  47. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  48. def toString(): String
    Definition Classes
    AnyRef → Any
  49. final def union[N2 >: N, E2 >: E <: Edge[N2]](that: AnyGraph[N2, E2]): CC[N2, E2]

    Computes the union between this graph and that graph.

    Computes the union between this graph and that graph.

    Annotations
    @inline()
  50. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  51. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException]) @native()
  52. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  53. final def |(that: AnyGraph[N, E]): CC[N, E]

    Alias for union.

    Alias for union.

    Annotations
    @inline()
  54. object InnerEdge
  55. object InnerNode

Deprecated Value Members

  1. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.Throwable]) @Deprecated
    Deprecated
  2. def formatted(fmtstr: String): String
    Implicit
    This member is added by an implicit conversion from GraphOps[N, E, CC] toStringFormat[GraphOps[N, E, CC]] performed by method StringFormat in scala.Predef.
    Definition Classes
    StringFormat
    Annotations
    @deprecated @inline()
    Deprecated

    (Since version 2.12.16) Use formatString.format(value) instead of value.formatted(formatString), or use the f"" string interpolator. In Java 15 and later, formatted resolves to the new method in String which has reversed parameters.

  3. def →[B](y: B): (GraphOps[N, E, CC], B)
    Implicit
    This member is added by an implicit conversion from GraphOps[N, E, CC] toArrowAssoc[GraphOps[N, E, CC]] performed by method ArrowAssoc in scala.Predef.
    Definition Classes
    ArrowAssoc
    Annotations
    @deprecated
    Deprecated

    (Since version 2.13.0) Use -> instead. If you still wish to display it as one character, consider using a font with programming ligatures such as Fira Code.

Inherited from OuterElems[N, E]

Inherited from AnyRef

Inherited from Any

Inherited by implicit conversion any2stringadd fromGraphOps[N, E, CC] to any2stringadd[GraphOps[N, E, CC]]

Inherited by implicit conversion StringFormat fromGraphOps[N, E, CC] to StringFormat[GraphOps[N, E, CC]]

Inherited by implicit conversion Ensuring fromGraphOps[N, E, CC] to Ensuring[GraphOps[N, E, CC]]

Inherited by implicit conversion ArrowAssoc fromGraphOps[N, E, CC] to ArrowAssoc[GraphOps[N, E, CC]]

Ungrouped