All Classes and Interfaces
Class
Description
Abstract superclass for
Acceptor.Deprecated, for removal: This API element is subject to removal in a future version.
AbstractConcatNode<LeftTuple_ extends AbstractTuple,RightTuple_ extends AbstractTuple,OutTuple_ extends AbstractTuple>
Implements the concat operation.
A config class is a user-friendly, validating configuration class that maps XML input.
AbstractConstraint<Solution_,Constraint_ extends AbstractConstraint<Solution_,Constraint_,ConstraintFactory_>,ConstraintFactory_ extends InnerConstraintFactory<Solution_,Constraint_>>
AbstractConstraintStreamScoreDirectorFactory<Solution_,Score_ extends Score<Score_>,Factory_ extends AbstractConstraintStreamScoreDirectorFactory<Solution_,Score_,Factory_>>
FP streams implementation of
ScoreDirectorFactory.Abstract superclass for
CountableValueRange (and therefore ValueRange).It is expected that if two instances share the same properties,
they are
equal to one another.Abstract superclass for
EntityPlacer.Abstract superclass for
FinalistPodium.AbstractFlattenLastNode<InTuple_ extends AbstractTuple,OutTuple_ extends AbstractTuple,EffectiveItem_,FlattenedItem_>
Filtering nodes are expensive.
Represents the various lifecycle operations that can be performed
on tuples within a node in Bavet.
This and its subclasses exist so that Gizmo only needs to generate code where it is necessary for it to be generated.
AbstractGroupNode<InTuple_ extends AbstractTuple,OutTuple_ extends AbstractTuple,GroupKey_,ResultContainer_,Result_>
This class has two direct children:
AbstractIndexedIfExistsNode and AbstractUnindexedIfExistsNode.There is a strong likelihood that any change to this class, which is not related to indexing,
should also be made to
AbstractUnindexedIfExistsNode.There is a strong likelihood that any change to this class, which is not related to indexing,
should also be made to
AbstractUnindexedJoinNode.This class has two direct children:
AbstractIndexedJoinNode and AbstractUnindexedJoinNode.Abstract superclass for
LocalSearchForager.Abstract superclass for
Move, requiring implementation of undo moves.Abstract superclass for
MoveSelector.AbstractMoveSelectorFactory<Solution_,MoveSelectorConfig_ extends MoveSelectorConfig<MoveSelectorConfig_>>
Deprecated, for removal: This API element is subject to removal in a future version.
Implement
Score instead.Abstract superclass for
ScoreDefinition.AbstractScoreDirector<Solution_,Score_ extends Score<Score_>,Factory_ extends AbstractScoreDirectorFactory<Solution_,Score_,Factory_>>
Abstract superclass for
ScoreDirector.AbstractScoreDirector.AbstractScoreDirectorBuilder<Solution_,Score_ extends Score<Score_>,Factory_ extends AbstractScoreDirectorFactory<Solution_,Score_,Factory_>,Builder_ extends AbstractScoreDirector.AbstractScoreDirectorBuilder<Solution_,Score_,Factory_,Builder_>>
An abstract builder for creating instances of
InnerScoreDirector.AbstractScoreDirectorFactory<Solution_,Score_ extends Score<Score_>,Factory_ extends AbstractScoreDirectorFactory<Solution_,Score_,Factory_>>
Abstract superclass for
ScoreDirectorFactory.Keeps track of the working score and constraint matches for a single constraint session.
Abstract superclass for
Selector.Deprecated, for removal: This API element is subject to removal in a future version.
In favor of
AbstractMove, which no longer requires undo moves to be implemented either.Common code between
DefaultSolver and child solvers.Abstract superclass for all Tabu Acceptors.
A tuple is an out tuple in exactly one node and an in tuple in one or more nodes.
Deprecated, for removal: This API element is subject to removal in a future version.
Uncountable value ranges were never fully supported in many places throughout the solver
and therefore never gained traction.
Deprecated, for removal: This API element is subject to removal in a future version.
Undo moves are automatically generated by the solver.
There is a strong likelihood that any change made to this class
should also be made to
AbstractIndexedIfExistsNode.There is a strong likelihood that any change made to this class
should also be made to
AbstractIndexedJoinNode.Some
Demand implementation classes are defined by their VariableDescriptor and nothing else.Common ancestor for specialized planning variable listeners.
A
LocalSearchForager which forages accepted moves and ignores unaccepted moves.An Acceptor accepts or rejects a selected
Move.Specifies that a bean property (or a field) is the anchor of a chained
PlanningVariable, which implies it's a shadow
variable.Only supported for chained variables.
Only selects values from the child value selector that are initialized.
Determines if and how to automatically presume
ConstraintWeightOverrides,
ProblemFactCollectionProperty, ProblemFactProperty, PlanningEntityCollectionProperty,
PlanningEntityProperty and PlanningScore annotations on PlanningSolution members
based on the member type.Exists to expose read-only view of
TopologicalOrderGraph.Stores a graph node id along its topological order.
Concurrency notes:
Condition predicate on (
BasicPlumbingTermination.problemChangeQueue is not empty or BasicPlumbingTermination.terminatedEarly is true).The type is public to make it easier for Bavet-specific minimal bug reproducers to be created.
FP streams implementation of
ScoreDirector, which only recalculates the Score
of the part of the working solution that changed,
instead of the going through the entire PlanningSolution.This
Score is based on n levels of BigDecimal constraints.This
Score is based on n levels of long constraints.This
Score is based on n levels of int constraints.Delivered when the
best solution changes during solving.Remembers the
best solution that a Solver encounters.Used to build a
Constraint out of a BiConstraintStream, applying optional configuration.As described by
UniConstraintCollector, only for BiConstraintStream.A
ConstraintStream that matches two facts.A filter that can be applied to a
BiDataStream to filter out pairs of data,
optionally using SolutionView to query for solution state.Created with
Joiners.Combs an array of
BiDataJoiner instances into a mergedJoiner and a mergedFiltering.A mapping function that can be applied to
BiDataStream to transform data,
optionally using SolutionView to query for solution state.Created with
Joiners.Combs an array of
BiJoiner instances into a mergedJoiner and a mergedFiltering.Investigate nodes layer by layer: investigate shallower nodes first.
Represents a gap between two
sequences.This
Iterator does not shuffle and is never ending.A
EntitySelector that caches the result of its child EntitySelector.A
MoveSelector that caches the result of its child MoveSelector.A
ValueSelector that caches the result of its child ValueSelector.A
CompositeMoveSelector that Cartesian products 2 or more MoveSelectors.Specifies that a field may be updated by the target method when any of its variables change, genuine or shadow.
Exists so that particular user-provided classes,
which are instantiated by Timefold from
SolverConfig,
only ever have one instance.To get an instance, demand a
CollectionInverseVariableDemand from InnerScoreDirector.getSupplyManager().Sorts a selection
List based on a Comparator.Combines several acceptors into one.
A CompositeMove is composed out of multiple other moves.
A CompositeMove is composed out of multiple other moves.
Abstract superclass for every composite
MoveSelector.A thread-safe memoization that caches a calculation.
ConnectedRange<Range_,Point_ extends Comparable<Point_>,Difference_ extends Comparable<Difference_>>
Represents a collection of ranges that are connected, meaning
the union of all the ranges results in the range
[
ConnectedRange.getStart(), ConnectedRange.getEnd()) without gaps.ConnectedRangeChain<Range_,Point_ extends Comparable<Point_>,Difference_ extends Comparable<Difference_>>
Contains info regarding
ConnectedRanges and RangeGaps for a collection of ranges.ConnectedRangeChainImpl<Range_,Point_ extends Comparable<Point_>,Difference_ extends Comparable<Difference_>>
ConnectedRangesCalculator<Interval_,Point_ extends Comparable<Point_>,Difference_ extends Comparable<Difference_>>
ConnectedRangeTracker<Range_,Point_ extends Comparable<Point_>,Difference_ extends Comparable<Difference_>>
ConsecutiveSetTree<Value_,Point_ extends Comparable<Point_>,Difference_ extends Comparable<Difference_>>
A
ConsecutiveSetTree determines what values are consecutive.A class that holds common lambdas that are guaranteed to be the same across method calls.
This represents a single constraint in the
ConstraintStream API
that impacts the Score.Note: Users should never create instances of this type directly.
Creates an
UniConstraintCollector, BiConstraintCollector, ... instance
for use in UniConstraintStream.groupBy(Function, UniConstraintCollector), ...Deprecated, for removal: This API element is subject to removal in a future version.
Use
ConstraintWeightOverrides instead.Deprecated, for removal: This API element is subject to removal in a future version.
Use
ConstraintWeightOverrides instead.Deprecated, for removal: This API element is subject to removal in a future version.
Use
ConstraintWeightOverrides instead.The factory to create every
ConstraintStream (for example with ConstraintFactory.forEach(Class))
which ends in a Constraint returned by ConstraintProvider.defineConstraints(ConstraintFactory).Marker interface for constraint justifications.
Retrievable from
ConstraintMatchTotal.getConstraintMatchSet()
and Indictment.getConstraintMatchSet().Allows a
IncrementalScoreCalculator to report ConstraintMatchTotals
for explaining a score (= which score constraints match for how much)
and also for score corruption analysis.Determines whether constraint match is enabled and whether constraint match justification is enabled.
Allows creating
ConstraintMatch instances lazily if and only if they are required by the end user.Provides information about the known constraints.
Used by Constraint Streams'
Score calculation.Represents a unique identifier of a constraint.
Deprecated, for removal: This API element is subject to removal in a future version.
There is only one implementation.
Deprecated, for removal: This API element is subject to removal in a future version.
Use
ConstraintWeightOverrides instead.Used to override constraint weights defined in Constraint Streams,
e.g., in
UniConstraintStream.penalize(Score).A
ConstructionHeuristicPhase is a Phase which uses a construction heuristic algorithm,
such as First Fit, First Fit Decreasing, Cheapest Insertion, ...An adapter for
ConstructionHeuristicPhaseLifecycleListener.A
ValueRange that is ending.Used for converting selector size to some other value.
Deprecated, for removal: This API element is subject to removal in a future version.
Use
PhaseCommand instead.Deprecated, for removal: This API element is subject to removal in a future version.
Deprecated in favor of
ShadowVariable (normal shadow variable with CustomShadowVariable.variableListenerClass())
and PiggybackShadowVariable (if CustomShadowVariable.variableListenerRef() is used).Workaround for annotation limitation in
CustomShadowVariable.variableListenerClass().Creates an
BiDataJoiner, ... instance
for use in UniDataStream.join(Class, BiDataJoiner[]), ...Marks a problem fact class as being required to be deep planning cloned.
Default implementation of
ConstraintJustification, returned by ConstraintMatch.getJustification()
unless the user defined a custom justification mapping.If possible, prefer using
SolutionManager.analyze(Object) instead.Default implementation of
ConstructionHeuristicPhase.Default implementation of
CustomPhase.Default implementation of
ExhaustiveSearchPhase.Default implementation of
LocalSearchPhase.Deprecated, for removal: This API element is subject to removal in a future version.
Prefer
DefaultRecommendedAssignment instead.Deprecated, for removal: This API element is subject to removal in a future version.
Use
DefaultSolutionManager instead.Default implementation for
Solver.Similar to
Executors's DefaultThreadFactory, but allows settings a namePrefix.This is the common
SubChainSelector implementation.A subsystem submits a demand for a
Supply.Investigate deeper nodes first.
Determines how members (fields and methods) of the domain (for example the
planner variable)
are accessed.Deprecated, for removal: This API element is subject to removal in a future version.
Prefer
BigDecimalValueRange.A class representing an int array that is dynamically allocated based on the first set index.
Used for easy java
Score calculation.Easy java implementation of
ScoreDirector, which recalculates the Score
of the working solution every time.Easy implementation of
ScoreDirectorFactory.Linked list that allows to add and remove an element in O(1) time.
An entry of
ElementAwareListSelects destinations for list variable change moves.
A supertype for
PositionInList and UnassignedElement.Special range for empty value ranges.
A notifiable listening for
EntityNotifications.General superclass for
QueuedEntityPlacerConfig and PooledEntityPlacerConfig.Selects instances of 1
PlanningEntity annotated class.The manner of sorting
PlanningEntity instances.The environment mode also allows you to detect common bugs in your implementation.
A
ExhaustiveSearchPhase is a Phase which uses an exhaustive algorithm, such as Brute Force.Alternative to
AnchorVariableListener.Alternative to
CollectionInverseVariableListener.Alternative to
SingletonInverseVariableListener.This class is thread-safe; score directors from the same solution descriptor will share the same instance.
The decorator returns a list of reachable entities for a specific entity.
The decorator returns a list of reachable entities for a specific value.
The decorator returns a list of reachable values for a specific value.
A podium gathers the finalists (the
LocalSearchMoveScopes which might win) and picks the winner.This is the common
ValueSelector implementation.This is the common
EntitySelector implementation.Abstract superclass for every generic
MoveSelector.A
VariableMetaModel that represents a @basic planning variable.Loads a class if we have the Gizmo-generated bytecode for it,
otherwise uses the current
Thread's context ClassLoader.Generates the bytecode for the MemberAccessor of a particular Member
Describe and provide simplified/unified access for
Member.Group0Mapping3CollectorBiNode<OldA,OldB,A,B,C,ResultContainerA_,ResultContainerB_,ResultContainerC_>
Group0Mapping3CollectorQuadNode<OldA,OldB,OldC,OldD,A,B,C,ResultContainerA_,ResultContainerB_,ResultContainerC_>
Group0Mapping3CollectorTriNode<OldA,OldB,OldC,A,B,C,ResultContainerA_,ResultContainerB_,ResultContainerC_>
Group0Mapping4CollectorBiNode<OldA,OldB,A,B,C,D,ResultContainerA_,ResultContainerB_,ResultContainerC_,ResultContainerD_>
Group0Mapping4CollectorQuadNode<OldA,OldB,OldC,OldD,A,B,C,D,ResultContainerA_,ResultContainerB_,ResultContainerC_,ResultContainerD_>
Group0Mapping4CollectorTriNode<OldA,OldB,OldC,A,B,C,D,ResultContainerA_,ResultContainerB_,ResultContainerC_,ResultContainerD_>
Group0Mapping4CollectorUniNode<OldA,A,B,C,D,ResultContainerA_,ResultContainerB_,ResultContainerC_,ResultContainerD_>
Group1Mapping3CollectorBiNode<OldA,OldB,A,B,C,D,ResultContainerB_,ResultContainerC_,ResultContainerD_>
Group1Mapping3CollectorQuadNode<OldA,OldB,OldC,OldD,A,B,C,D,ResultContainerB_,ResultContainerC_,ResultContainerD_>
Group1Mapping3CollectorTriNode<OldA,OldB,OldC,A,B,C,D,ResultContainerB_,ResultContainerC_,ResultContainerD_>
GroupNodeConstructor.GroupBy0Mapping2CollectorNodeBuilder<CollectorA_,CollectorB_,Tuple_ extends AbstractTuple>
GroupNodeConstructor.GroupBy0Mapping3CollectorNodeBuilder<CollectorA_,CollectorB_,CollectorC_,Tuple_ extends AbstractTuple>
GroupNodeConstructor.GroupBy0Mapping4CollectorNodeBuilder<CollectorA_,CollectorB_,CollectorC_,CollectorD_,Tuple_ extends AbstractTuple>
GroupNodeConstructor.GroupBy1Mapping1CollectorNodeBuilder<KeyA_,CollectorB_,Tuple_ extends AbstractTuple>
GroupNodeConstructor.GroupBy1Mapping2CollectorNodeBuilder<KeyA_,CollectorB_,CollectorC_,Tuple_ extends AbstractTuple>
GroupNodeConstructor.GroupBy1Mapping3CollectorNodeBuilder<KeyA_,CollectorB_,CollectorC_,CollectorD_,Tuple_ extends AbstractTuple>
GroupNodeConstructor.GroupBy2Mapping1CollectorNodeBuilder<KeyA_,KeyB_,CollectorC_,Tuple_ extends AbstractTuple>
GroupNodeConstructor.GroupBy2Mapping2CollectorNodeBuilder<KeyA_,KeyB_,CollectorC_,CollectorD_,Tuple_ extends AbstractTuple>
GroupNodeConstructor.GroupBy3Mapping0CollectorNodeBuilder<KeyA_,KeyB_,KeyC_,Tuple_ extends AbstractTuple>
GroupNodeConstructor.GroupBy3Mapping1CollectorNodeBuilder<KeyA_,KeyB_,KeyC_,CollectorD_,Tuple_ extends AbstractTuple>
GroupNodeConstructor.GroupBy4Mapping0CollectorNodeBuilder<KeyA_,KeyB_,KeyC_,KeyD_,Tuple_ extends AbstractTuple>
This
Score is based on 3 levels of BigDecimal constraints: hard, medium and soft.This
Score is based on 3 levels of long constraints: hard, medium and soft.This
Score is based on 3 levels of int constraints: hard, medium and soft.This
Score is based on 2 levels of BigDecimal constraints: hard and soft.This
Score is based on 2 levels of long constraints: hard and soft.This
Score is based on 2 levels of int constraints: hard and soft.Default implementation of
FinalistPodium.Bendable score is a
Score whose IBendableScore.hardLevelsSize() and IBendableScore.softLevelsSize()
are only known at runtime.Used for incremental java
Score calculation.Incremental java implementation of
ScoreDirector, which only recalculates the Score
of the part of the working solution that changed,
instead of the going through the entire PlanningSolution.Incremental implementation of
ScoreDirectorFactory.An indexer for entity or fact
X,
maps a property or a combination of properties of X, denoted by indexKeys,
to all instances of X that match those properties,
depending on the the indexer type (equal, lower than, ...).Indexers form a parent-child hierarchy,
each child has exactly one parent.Represents a function which extracts index keys from a tuple.
Cached in tuples; each tuple carries its unique instance.
Specifies that a bean property (or a field) is an index of this planning value in another entity's
PlanningListVariable.Only supported for
list variables.Prevents creating chains without an anchor.
Bounds the possible
Scores for a PlanningSolution as more and more variables are initialized
(while the already initialized variables don't change).Bounds 1 score level of the possible
Scores for a PlanningSolution as more and more variables are initialized
(while the already initialized variables don't change).Carries information on if the
PlanningSolution of this score was fully initialized when it was calculated.Specifies that a bean property (or a field) is the inverse of a
PlanningVariable, which implies it's a shadow
variable.The value range for list variables requires the selector to be entity-independent,
as it needs to fetch the entire list of values.
This is the common
ValueSelector implementation.Creates an
BiJoiner, TriJoiner, ... instance
for use in UniConstraintStream.join(Class, BiJoiner), ...THIS CLASS IS EXPERIMENTAL AND UNSUPPORTED.
Adapts
a legacy move
to a new move.This set does not support null keys.
An ordered
Set which is implemented as a ArrayList for a small Set.size()
and a LinkedHashSet for a big Set.size().Moves an element of a
list variable.Moves an element of a
list variable.For each unassigned value, creates a move to assign it to some position of some list variable.
An extension on the
Iterable interface that supports ListIterable.listIterator() and ListIterable.listIterator(int).Swaps two elements of a
list variable.Swaps two elements of a
list variable.A listener sourced on a
PlanningListVariable.Single source of truth for all information about elements inside
list variables.Tracks variable listener events for a given
PlanningListVariable.Calculates the unfairness measure for a particular input.
Collects the moves and picks the next step from those for the
LocalSearchDecider.A
LocalSearchPhase is a Phase which uses a Local Search algorithm,
such as Tabu Search, Simulated Annealing,
Late Acceptance, ...An adapter for
LocalSearchPhaseLifecycleListener.This class is thread-safe.
Deprecated, for removal: This API element is subject to removal in a future version.
When multi-threaded solving, ensure your domain classes use @
PlanningId instead.Note: Users should never create instances of this type directly.
Supply whose value is pre-computed and cached the first time
MemoizingSupply.read() is called.A Move represents a change of 1 or more
PlanningVariables of 1 or more PlanningEntitys
in the working PlanningSolution.A Move represents a change of 1 or more
PlanningVariables of 1 or more PlanningEntitys
in the working PlanningSolution.Allows for reading data produced by a temporary move, before it is undone.
Bridges a
MoveIteratorFactory to a MoveSelector.Bridges a
MoveListFactory to a MoveSelector.Implement this to provide a definition for one move type.
This is a shared abstraction for all three types of move iterators currently used in the solver:
MoveSelectorBasedMoveRepository for local search and exhaustive search.
PlacerBasedMoveRepository for construction heuristics.
MoveStreamsBasedMoveRepository for move streams.
As move streams become gradually more capable,
these extra implementations will be removed
until only MoveStreamsBasedMoveRepository remains in use.Generates
Moves.General superclass for
ChangeMoveSelectorConfig, etc.A mutable key-value tuple.
Contains all reading and mutating methods available to a
Move
in order to change the state of a planning solution.For move selectors that support Nearby Selection autoconfiguration.
Implementations are expected to be stateless.
Specifies that a bean property (or a field) references the next element in the same
PlanningListVariable.Points to a list variable next and previous elements position specified by an entity.
Makes no changes.
Deprecated, for removal: This API element is subject to removal in a future version.
Deprecated on account of having no use.
Deprecated, for removal: This API element is subject to removal in a future version.
Deprecated on account of deprecating
NoChangePhase.Deprecated, for removal: This API element is subject to removal in a future version.
Deprecated on account of deprecating
NoChangePhase.Represents Bavet's network of nodes, specific to a particular session.
A notifiable’s purpose is to execute variable listener methods.
A notification represents some kind of change of a planning variable.
Investigate the nodes with a better optimistic bound first, then deeper nodes.
Investigate deeper nodes first, in order.
An immutable key-value tuple.
A
PartitionedSearchPhase is a Phase which uses a Partition Search algorithm.Represents a function that accepts five arguments and produces a result.
Created with
Joiners.Combs an array of
PentaJoiner instances into a mergedJoiner and a mergedFiltering.Represents a predicate (boolean-valued function) of five arguments.
A phase of a
Solver.An adapter for
PhaseLifecycleListener.Internal API.
Determines when a
Phase should stop.Specifies that a bean property (or a field) is a custom shadow variable that is updated by another shadow variable's
variable listener.
Workaround for annotation limitation in
PiggybackShadowVariable.shadowEntityClass().This
Move is not cacheable.A pillar is a
List of entities that have the same planning value for each (or a subset)
of their planning values.This
Move is not cacheable.Deprecated, for removal: This API element is subject to removal in a future version.
Use
PlanningPin instead.Used to construct new instances of an object when there is no suitable constructor.
Specifies that the class is a planning entity.
Workaround for annotation limitation in
PlanningEntity.difficultyComparatorClass().Workaround for annotation limitation in
PlanningEntity.difficultyWeightFactoryClass().Deprecated, for removal: This API element is subject to removal in a future version.
Prefer using
PlanningPin.Specifies that a property (or a field) on a
PlanningSolution class is a Collection of planning entities.A diff between two instances of a
PlanningEntity,
where at least one variable of that entity (genuine or shadow) changed.Represents the meta-model of an entity.
Specifies that a property (or a field) on a
PlanningSolution class is a planning entity.This interface is used to mark an object as immutable.
Specifies that a bean property (or a field) can be changed and should be optimized by the optimization algorithms.
A
VariableMetaModel that represents a @list planning variable.Specifies that a boolean property (or field) of a
PlanningEntity determines if the planning entity is pinned.Specifies that an
int property (or field) of a PlanningEntity determines
how far a PlanningListVariable is pinned.Specifies that a property (or a field) on a
PlanningSolution class holds the Score of that solution.Deprecated, for removal: This API element is subject to removal in a future version.
Specifies that the class is a planning solution.
Workaround for annotation limitation in
PlanningSolution.solutionCloner().A diff between two instances of a
PlanningSolution.Represents the meta-model of a
PlanningSolution.Specifies that a bean property (or a field) can be changed and should be optimized by the optimization algorithms.
Workaround for annotation limitation in
PlanningVariable.strengthComparatorClass().Workaround for annotation limitation in
PlanningVariable.strengthWeightFactoryClass().A diff between two values of a single planning variable of a single
PlanningEntity,
Obtain from PlanningEntityDiff.A
VariableMetaModel that represents a @basic planning variable.A reference to a genuine
PlanningVariable or a shadow variable.Workaround for annotation limitation in
PlanningVariableReference.entityClass().Uniquely identifies the position of a value in a list variable.
Describes a phase that can be used to initialize a solution.
The status with which the phase terminated.
Lists features available in Timefold Solver on a preview basis.
Specifies that a bean property (or a field) references the previous element in the same
PlanningListVariable.A ProblemChange represents a change in one or more
planning entities or problem facts
of a PlanningSolution.Provides a layer of abstraction over
ProblemChange and the
deprecated ProblemFactChange to preserve backward compatibility.Allows external changes to the
working solution.Deprecated, for removal: This API element is subject to removal in a future version.
Prefer
ProblemChange.Specifies that a property (or a field) on a
PlanningSolution class is a Collection of problem facts.Specifies that a property (or a field) on a
PlanningSolution class is a problem fact.The statistics of a given problem submitted to a
Solver.A propagation queue is an ordered collection of items that need to be sent to the next node.
Propagator is an interface that exposes the
PropagationQueue to BavetConstraintSession.Used to build a
Constraint out of a QuadConstraintStream, applying optional configuration.As described by
UniConstraintCollector, only for QuadConstraintStream.A
ConstraintStream that matches four facts.Represents a function that accepts four arguments and returns no result.
Represents a function that accepts four arguments and produces a result.
Created with
Joiners.Combs an array of
QuadJoiner instances into a mergedJoiner and a mergedFiltering.Represents a predicate (boolean-valued function) of four arguments.
An immutable tuple of four values.
Defines the pseudo random number generator.
A
RangeGap is a gap between two consecutive ConnectedRanges.This class records the relationship between each planning value and all entities that include the related value
within its value range.
Allows to transfer an entity or fact instance (often from another
Thread)
to another ScoreDirector's internal working instance.Represents the result of the Assignment Recommendation API,
see
SolutionManager.recommendFit(Object, Object, Function).Deprecated, for removal: This API element is subject to removal in a future version.
Prefer
RecommendedAssignment instead.A
MemberAccessor based on a getter and optionally a setter.A
MemberAccessor based on a field.A
MemberAccessor based on a single read Method.Prevents reassigning of already initialized variables during Construction Heuristics and Exhaustive Search.
Determines the behavior of joins and conditional propagation
based on whether they are coming off of a constraint stream started by
either
ConstraintFactory.from(Class)
or ConstraintFactory.forEach(Class)
family of methods.A Score is result of the score function (AKA fitness function) on a single possible solution.
Represents the breakdown of a
Score into individual ConstraintAnalysis instances,
one for each constraint.Determines the depth of
score analysis.The ScoreDirector holds the
working solution
and calculates the Score for it.Build by
SolutionManager.explain(Object) to hold ConstraintMatchTotals and Indictments
necessary to explain the quality of a particular Score.Investigate the nodes with a better optimistic bound first, then deeper nodes.
Deprecated, for removal: This API element is subject to removal in a future version.
Use
SolutionManager instead.There is no INHERIT by design because 2 sequential caches provides no benefit, only memory overhead.
Decides on accepting or discarding a selection,
which is either a
PlanningEntity, a planning value, a Move or a Selector).Defines in which order the elements or a selector are selected.
Create a probabilityWeight for a selection
(which is a
PlanningEntity, a planningValue, a Move or a Selector).Decides the order of a
List of selection
(which is a PlanningEntity, a planningValue, a Move or a Selector).Creates a weight to decide the order of a collections of selections
(a selection is a
PlanningEntity, a planningValue, a Move or a Selector).General interface for
MoveSelector, EntitySelector and ValueSelector
which generates Moves or parts of them.Represents a series of consecutive values.
Contains info regarding the consecutive sequences and breaks in a collection of points.
Used throughout the solver to provide access to some internals of the score director
required for initialization of Bavet nodes and other components.
Specifies the paths to variables that a method referenced by
ShadowVariable.supplierName()
uses to compute the value of a ShadowVariable.Specifies that a bean property (or a field) is a custom shadow variable of 1 or more source variables.
Defines several
ShadowVariable annotations on the same element.Workaround for annotation limitation in
ShadowVariable.sourceEntityClass().Workaround for annotation limitation in
ShadowVariable.variableListenerClass().A
VariableMetaModel that represents a shadow planning variable.Serves for detecting shadow variables' corruption.
Specifies that a boolean property (or field) of a
PlanningEntity
tracks if any of its supplier variables
are inconsistent.Utility class for updating shadow variables at entity level.
This
Score is based on 1 level of BigDecimal constraints.This
Score is based on 1 level of long constraints.This
Score is based on 1 level of int constraints.The time gradient implementation of simulated annealing.
Currently only supported for chained variables and
list variables,
which guarantee that no 2 entities use the same planningValue.Clones a
PlanningSolution during planning.Splits one
solution into multiple partitions.To fully de-normalize a planning solution freshly loaded from persistent storage,
two operations need to happen:
Variable listeners need to run,
reading the state of all entities and computing values for their shadow variables.
Score needs to be calculated and stored on the planning solution.
Allows read-only access to the state of the solution that is being operated on by the
Move.A Solver solves a planning problem and returns the best solution found.
To read it from XML, use
SolverConfig.createFromXmlResource(String).Includes settings to override default
Solver configuration.Internal API.
Creates
Solver instances.Represents a
problem that has been submitted to solve on the SolverManager.Provides a fluent contract that allows customization and submission of planning problems to solve.
A consumer that accepts the first initialized solution.
An adapter for
SolverLifecycleListener.Identifies which move thread, which phase, step and move/move tree the solver is currently executing.
A SolverManager solves multiple planning problems of the same domain,
asynchronously without blocking the calling thread.
The status of
problem submitted to the SolverManager.Determines when a
Solver should stop.Used to externalize data for a
Supply from the domain model itself.A
SolverStatistic that has no state or event listenerThe implementation moves tuples directly into an either retract, update or insert queue,
without any option of moving between the queues.
Determines what increment the counter of Step Counting Hill Climbing.
Strategic oscillation, works well with Tabu search.
A subList out of a single chain.
This
Move is not cacheable.This
Move is not cacheable.Supplies something for 1 or multiple subsystems.
Swaps values of
PlanningVariable between two different PlanningEntity instances.Also known as a 2-opt move.
Also known as a 2-opt move selector.
Also known as a 2-opt move selector config.
TerminalDataStream<Solution_,Tuple_ extends AbstractTuple,Dataset_ extends AbstractDataset<Solution_,Tuple_>>
Determines when a
Phase should stop.Represents a function that accepts four arguments and produces an int-valued result.
Represents a function that accepts three arguments and produces an int-valued result.
Represents a function that accepts four arguments and produces a long-valued result.
Represents a function that accepts three arguments and produces a long-valued result.
Used to build a
Constraint out of a TriConstraintStream, applying optional configuration.As described by
UniConstraintCollector, only for TriConstraintStream.A
ConstraintStream that matches three facts.Represents a function that accepts three arguments and returns no result.
Represents a function that accepts three arguments and produces a result.
Created with
Joiners.Combs an array of
TriJoiner instances into a mergedJoiner and a mergedFiltering.An immutable tuple of three values.
Represents a predicate (boolean-valued function) of three arguments.
A 2-opt move for list variables, which takes two edges and swap their endpoints.
Identifies that a given value was not found in any
PlanningEntity's list variables.Only selects values from the child value selector that are uninitialized.
An exception that is thrown in
EnvironmentMode.TRACKED_FULL_ASSERT when undo score corruption is detected.Used to build a
Constraint out of a UniConstraintStream, applying optional configuration.Usually created with
ConstraintCollectors.A
ConstraintStream that matches one fact.A filter that can be applied to a
UniDataStream to filter out pairs of data,
optionally using SolutionView to query for solution state.A mapping function that can be applied to
UniDataStream to transform data,
optionally using SolutionView to query for solution state.A
CompositeMoveSelector that unions 2 or more MoveSelectors.IMPORTANT: The constructor of any subclass of this abstract class, should never call any of its child
Selector's Iterator.hasNext() or Iterator.next() methods,
because that can cause descendant Selectors to be selected too early
(which breaks MimicReplayingEntitySelector).A ValueRange is a set of a values for a
PlanningVariable or PlanningListVariable.Instances should be created using the
ValueRangeCache.Builder enum.Factory for
CountableValueRange.Caches value ranges for the current working solution,
allowing to quickly access these cached value ranges when needed.
Provides the planning values that can be used for a
PlanningVariable.Selects values from the
ValueRangeProvider for a PlanningVariable annotated property.The manner of sorting values for a
PlanningVariable.Each before/after event needs to look up a variable descriptor.
A
VariableId is an entity/variable of a given solution.A listener sourced on a basic
PlanningVariable.This class is not thread-safe.
Holds a variable listener and all its source variable descriptors.
Describes a variable in the domain model.
A
VariableSnapshot is a snapshot of the value of a variable for a given entity.Serves for detecting undo move corruption.
Tracks variable listener events for a given genuine or shadow variable
(except
PlanningListVariable).There are several valid ways how an impacter could be called from a constraint stream:
.penalize(..., (int) 1)
.penalizeLong(..., (int) 1)
.penalizeLong(..., (long) 1)
.penalizeBigDecimal(..., (int) 1)
.penalizeBigDecimal(..., (long) 1)
.penalizeBigDecimal(..., BigDecimal.ONE)
Plus reward variants of the above.
An implementation of this interface can throw an UnsupportedOperationException
for the method types it doesn't support.WeightedScoreImpacter.BigDecimalImpactFunction<Score_ extends Score<Score_>,Context_ extends ScoreContext<Score_,?>>
WeightedScoreImpacter.IntImpactFunction<Score_ extends Score<Score_>,Context_ extends ScoreContext<Score_,?>>
WeightedScoreImpacter.LongImpactFunction<Score_ extends Score<Score_>,Context_ extends ScoreContext<Score_,?>>
Sorts a selection
List based on a SelectionSorterWeightFactory.
IBendableScoreinstead.