trait GraphOps[N, E <: Edge[N], +CC[X, Y <: Edge[X]]] extends OuterElems[N, E]
Operations common to mutable and immutable graphs.
- Alphabetic
- By Inheritance
- GraphOps
- OuterElems
- AnyRef
- Any
- by any2stringadd
- by StringFormat
- by Ensuring
- by ArrowAssoc
- Hide All
- Show All
- Public
- Protected
Type Members
- type EdgePredicate = (EdgeT) => Boolean
- abstract type EdgeT <: InnerEdge
- trait InnerEdge extends InnerElem
- sealed trait InnerElem extends AnyRef
- trait InnerNode extends InnerElem
- type NodePredicate = (NodeT) => Boolean
- abstract type NodeT <: InnerNode
- 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
- trait OuterElem extends AnyRef
- Definition Classes
- OuterElems
- 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
- abstract def anyEdge: EdgePredicate
Edge predicate with constant
true
. - abstract def anyNode: NodePredicate
Node predicate with constant
true
. - 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
andisolatedNodes
omitting duplicates.Creates a new graph by adding all
edges
andisolatedNodes
omitting duplicates. The new graph is upcasted if any of the arguments is an upcast ofN
respectivelyE
. Useunion
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.
- abstract def contains(edge: E): Boolean
Whether the given outer edge is contained in this graph.
- abstract def contains(node: N): Boolean
Whether the given outer node is contained in this graph.
- abstract def filter(nodeP: NodePredicate = anyNode, edgeP: EdgePredicate = anyEdge): CC[N, E]
Computes a new graph with nodes satisfying
nodeP
and edges satisfyingedgeP
.Computes a new graph with nodes satisfying
nodeP
and edges satisfyingedgeP
. If bothnodeP
andedgeP
have default values the original graph is retained. - 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.
- 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.
- 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
respectivelyfEdge
.Creates a new graph with nodes and edges returned by
fNode
respectivelyfEdge
.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 typeN
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. Callouter
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).
- 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 typeN
of the node. IffNode
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).
- 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
respectivelyfEdge
.Creates a new graph with nodes and edges returned by
fNode
respectivelyfEdge
.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 typeN
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. Callouter
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).
- 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 typeN
of the node. IffNode
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.
- 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
respectivelyfEdge
.Creates a new graph with nodes and edges returned by
fNode
respectivelyfEdge
.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 typeN
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. Callouter
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).
- 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
respectivelyfEdge
.Creates a new graph with nodes and edges returned by
fNode
respectivelyfEdge
.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 typeN
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. Callouter
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).
- 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
respectivelyfEdge
.Creates a new graph with nodes and edges returned by
fNode
respectivelyfEdge
.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 typeN
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. Callouter
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 supplyingSome
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).
- 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
respectivelyfEdge
.Creates a new graph with nodes and edges returned by
fNode
respectivelyfEdge
.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 typeN
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. Callouter
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 supplyingSome
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).
- 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 thanopEdge
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.
- 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.
- 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.
- abstract def isDirected: Boolean
Whether all edges of this graph are directed.
- abstract def isHyper: Boolean
Whether this graph contains at least one hyperedge.
- abstract def isMixed: Boolean
Whether this graph contains at least one directed and one undirected edge.
- 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
- two or more directed edges having the same source and target
- two or more undirected edges connecting the same nodes
- two or more (directed) hyperedges that, after being decomposed into (directed) edges, yield any multy-edge as stipulated above.
- abstract def iterator: Iterator[InnerElem]
Iterator over all inner nodes and edges.
- 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 typeN
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. Callouter
to get the outer edge of type E.- returns
The mapped graph with possibly changed node and edge type parameters.
- 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 typeN
of the node.- returns
The mapped graph with possibly changed node and edge type parameters.
- 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 typeN
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. Callouter
to get the outer edge of type E.- returns
The mapped graph with possibly changed node and edge type parameters.
- 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 typeN
of the node.- returns
The mapped graph with possibly changed node and edge type parameters.
- 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 typeN
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. Callouter
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.
- 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 typeN
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. Callouter
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.
- 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 typeN
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. Callouter
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 supplyingSome
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.
- 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 typeN
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. Callouter
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 supplyingSome
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.
- abstract def noEdge: EdgePredicate
Edge predicate with constant
false
. - abstract def noNode: NodePredicate
Node predicate with constant
false
. - abstract def order: Int
The order, commonly referred to as |G|, of this graph equaling to the number of nodes.
- abstract def outerIterator: Iterator[OuterElem]
Iterator over all inner nodes and edges.
- abstract def removedAll(isolatedNodes: IterableOnce[N], edges: IterableOnce[E]): CC[N, E]
- Attributes
- protected
- abstract def size: Int
The size, commonly referred to as ||G||, of this graph equaling to the number of edges.
- abstract def toIterable: Iterable[InnerElem]
Iterable over all nodes and edges.
- abstract def toOuterIterable: Iterable[OuterElem]
Iterable over all nodes and edges.
- abstract def totalWeight: Double
The Sum of the weight of all edges.
Concrete Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##: Int
- Definition Classes
- AnyRef → Any
- final def &(that: AnyGraph[N, E]): CC[N, E]
Alias for
intersect
.Alias for
intersect
.- Annotations
- @inline()
- final def &~(that: AnyGraph[N, E]): CC[N, E]
Alias for
diff
.Alias for
diff
.- Annotations
- @inline()
- def +(other: String): String
- 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()
- 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()
- def ->[B](y: B): (GraphOps[N, E, CC], B)
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- 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()
- 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()
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native() @HotSpotIntrinsicCandidate()
- 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 emptyisolatedNodes
.Same as
concat(isolatedNodes, edges)
but with emptyisolatedNodes
. This method is useful if you don't need to pass any isolated node. - final def diff(that: AnyGraph[N, E]): CC[N, E]
Computes a new graph that is the difference of this graph and
that
graph. - final def elementCount: Int
The number of nodes and edges.
The number of nodes and edges.
- Annotations
- @inline()
- def ensuring(cond: (GraphOps[N, E, CC]) => Boolean, msg: => Any): GraphOps[N, E, CC]
- def ensuring(cond: (GraphOps[N, E, CC]) => Boolean): GraphOps[N, E, CC]
- def ensuring(cond: Boolean, msg: => Any): GraphOps[N, E, CC]
- def ensuring(cond: Boolean): GraphOps[N, E, CC]
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- def filterNot(nodeP: NodePredicate = noNode, edgeP: EdgePredicate = noEdge): CC[N, E]
Computes a new graph without nodes satisfying
nodeP
and without edges satisfyingePred
.Computes a new graph without nodes satisfying
nodeP
and without edges satisfyingePred
. If bothnodeP
andePred
have default values the original graph is retained. - 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
respectivelyfEdge
.Creates a new graph with nodes and edges returned by
fNode
respectivelyfEdge
.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.
- 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
respectivelyfEdge
.Creates a new graph with nodes and edges returned by
fNode
respectivelyfEdge
.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.
- 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
respectivelyfEdge
.Creates a new graph with nodes and edges returned by
fNode
respectivelyfEdge
.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.
- 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
respectivelyfEdge
.Creates a new graph with nodes and edges returned by
fNode
respectivelyfEdge
.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.
- 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
respectivelyfEdge
.Creates a new graph with nodes and edges returned by
fNode
respectivelyfEdge
.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.
- 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
respectivelyfEdge
.Creates a new graph with nodes and edges returned by
fNode
respectivelyfEdge
.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.
- 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.
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- final def intersect(that: AnyGraph[N, E]): CC[N, E]
Computes the intersection between this graph and
that
graph. - final def isEmpty: Boolean
Whether this graph contains any node or any edge.
Whether this graph contains any node or any edge.
- Annotations
- @inline()
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- final def isTrivial: Boolean
true
if this graph has at most 1 node.true
if this graph has at most 1 node.- Annotations
- @inline()
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- final def nonTrivial: Boolean
true
if this graph has at least 2 nodes.true
if this graph has at least 2 nodes.- Annotations
- @inline()
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def toString(): String
- Definition Classes
- AnyRef → Any
- 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()
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def |(that: AnyGraph[N, E]): CC[N, E]
Alias for
union
.Alias for
union
.- Annotations
- @inline()
- object InnerEdge
- object InnerNode
Deprecated Value Members
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable]) @Deprecated
- Deprecated
- 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 ofvalue.formatted(formatString)
, or use thef""
string interpolator. In Java 15 and later,formatted
resolves to the new method in String which has reversed parameters.
- 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.
Welcome to the Graph for Scala API reference. Some suggested entry points:
AnyGraph
immutable.Graph
and its inner nodesmutable.Graph
and its inner nodes.edges
package and its subpackageshyperedges
package and its subpackages.labeled edges
packagemultilabeled edges
packagelabeled hyperedges
packagemultilabeled hyperedges
packageordered labeled hyperedges
packageordered multilabeled hyperedges
objectgeneric
package.GraphTraversal
andTraverserInnerNode
.RandomGraph
.GraphGen
.