Enables to quickly assemble immutable constrained graph companion modules.
Enables to quickly assemble immutable constrained graph companion modules. Example:
import scalax.collection.constrained.CompanionAlias import scalax.collection.constrained.constraints.Acyclic object DAG extends CompanionAlias[DiEdge](Acyclic withStringPrefix "DAG")
Aims defining a constraint valid for Graph
instances in the scope:
Aims defining a constraint valid for Graph
instances in the scope:
implicit val config: Config = Acyclic val g = Graph(0 ~> 3) // g is constrained to Acyclic
Template to be mixed in by any constrained graph class.
Template to be mixed in by any constrained graph class.
The user of the dynamically constrained class scalax.collection.constrained.Graph
or its mutable counterpart need not to be concerned about this trait because
it has been mixed in there. She only needs to pass the companion object for her Constraint
implementation.
Implementors of statically constrained graph classes have to mix in this trait in their constrained graph implementations.
ConstraintMethods
Template to be implemented and passed to a dynamically constrained graph class by the user.
Template to be implemented and passed to a dynamically constrained graph class
by the user. Note that mutable state will be lost on any operation yielding a
new graph. Thus it is essential to either design classes inheriting from Constraint
in a pure immutable manner or taking internally care of whether the state has been lost.
ConstraintMethods
Base trait for ordinary Constraint
companion objects.
Facilitates binary operations on ConstraintCompanion
s.
Base class for any operation on ConstraintCompanion
s.
This template contains handler methods that are called by constrained graphs whenever a constraint has been violated.
This template contains handler methods that are called by constrained graphs whenever a constraint has been violated.
These methods must be overridden to get the handlers become active.
This template contains all methods that constrained graphs call to decide whether operations altering a mutable graph or operations yielding a new graph from an immutable or mutable graph are valid.
This template contains all methods that constrained graphs call to decide whether operations altering a mutable graph or operations yielding a new graph from an immutable or mutable graph are valid.
Constraint methods are called on graph creation and node/edge addition and subtraction
at two points of time, respectively: prior to the operation and after the operation has
taken place but still may be rolled back. Thus,
constraint method names are prefixed by pre
or post
. Pre-ckecks return Abort
,
PostCheck
or Complete
while post-checks return Boolean stating whether the operation
should be committed or rolled back. Pre-checks can inspect the operands only. In contrast,
post-checks additionally allow to inspect the would-be graph after the operation has taken place
but has not yet been committed.
For performance reasons, implementations should prefer implementing pre-check methods. If it's necessary to check not only the operands but the whole would-be graph, the appropriate post-check methods should be overridden.
Default (immutable) directed acyclic Graph
.
Default (immutable) undirected acyclic Graph
.
A trait for dynamically constrained graphs.
A trait for dynamically constrained graphs.
the type of the nodes (vertices) in this graph.
the kind of the edges in this graph.
A template trait for graphs.
A template trait for graphs.
This trait provides the common structure and operations of immutable graphs independently of its representation.
If E
inherits DirectedEdgeLike
the graph is directed, otherwise it is undirected or mixed.
the user type of the nodes (vertices) in this graph.
the higher kinded type of the edges (links) in this graph.
the higher kinded type of the graph itself.
The return type of any pre-check.
The return type of any pre-check. followUp
contains the return status (follow-up
activity). Constraint
implementations are encouraged to extend this class to contain
further data calculated in course of the pre-check and reusable in the following post-check.
Default (immutable) undirected connected acyclic Graph
.
Companion object to configure Graph
instances in the scope including ArraySet.Hints
:
Companion object to configure Graph
instances in the scope including ArraySet.Hints
:
implicit val config = Config(Acyclic)(ArraySet.Hints(64, 0, 64, 75)) val g = Graph(0 ~> 3) // g is constrained to Acyclic using the above optimization hints
Companion module for default (immutable) directed acyclic Graph
.
Companion module for default (immutable) undirected acyclic Graph
.
Default factory for constrained graphs.
Default factory for constrained graphs. Graph instances returned from this factory will be immutable.
Enumerates the possible return statuses (also: follow-up activity) of a pre-check:
Abort
instructs the caller to cancel the operation because the pre-check failed;
PostCheck
means that the post-check (commit) still must be called;
Complete
means that the operation can safely be completed without invoking the post-check.
Companion module for default (immutable) undirected connected acyclic Graph
.
Converts constraint
to an instance of config.ConstrainedConfig
.
Predefined constraints that may be passed to constrained Graph
s.
Constraint representing a DAG.
Constraint representing a forest.
Mutable constrained graph templates.
Constraint representing an undirected tree.
Traits enabling to implement constraints and use constrained graphs.
Graphs may be constrained dynamically or statically.
Dynamically constrained means that a constraint is bound to a constrained
Graph
instance at initialization time. The constrainedGraph
will then delegate all calls to the methods ofConstraintMethods
andConstraintHandlerMethods
to the corresponding methods of the constraint bound to it. The immutable and mutable factoriesGraph
in this package yield dynamically constrained graphs.To make use of dynamically constrained graphs you may make use of the predefined constraints or provide an own implementation of
Constraint
along with its companion object. To initialize a graph with one or several combined constraints just call the graph factory methods of theconstraint
package passing.Statically constrained means that the graph class directly implements the methods declared in
ConstraintMethods
.