All Classes and Interfaces
Class
Description
Abstract superclass for
Acceptor.Deprecated, for removal: This API element is subject to removal in a future version.
Abstract superclass that combines multiple
Terminations.A config class is a user-friendly, validating configuration class that maps XML input.
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.This and its subclasses exist so that Gizmo only needs to generate code where it is necessary for it to be generated.
Abstract superclass for
LocalSearchForager.Abstract superclass for
Move.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_>>
Abstract superclass for
ScoreDirector.Abstract superclass for
ScoreDirectorFactory.Abstract superclass for
Selector.Common code between
DefaultSolver and child solvers.Abstract superclass for all Tabu Acceptors.
Abstract superclass for
Termination.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.
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 assigned.
Determines if and how to automatically presume
ConstraintConfigurationProvider, ProblemFactCollectionProperty, ProblemFactProperty,
PlanningEntityCollectionProperty, PlanningEntityProperty and PlanningScore annotations
on PlanningSolution members based from the member type.Concurrency notes:
Condition predicate on (
BasicPlumbingTermination.problemFactChangeQueue is not empty or BasicPlumbingTermination.terminatedEarly is true).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.Created with
Joiners.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.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.
Abstract superclass for every composite
MoveSelector.A thread-safe memoization that caches a calculation.
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, ...Allows end users to change the constraint weights, by not hard coding them.
Specifies that a property (or a field) on a
PlanningSolution class is a ConstraintConfiguration.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.Used by Constraint Streams'
Score calculation.Represents a unique identifier of a constraint.
Specifies that a bean property (or a field) set the constraint weight and score level of a constraint.
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.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().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
ExhaustiveSearchPhase.Default implementation of
LocalSearchPhase.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.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.
Points to a list variable position specified by an entity and an index.
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
IndexVariableListener.Alternative to
SingletonInverseVariableListener.Alternative to
SingletonListInverseVariableListener.This class is thread-safe.
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.This is the common
ValueSelector implementation.Abstract superclass for every generic
MoveSelector.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.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.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).Specifies that a bean property (or a field) is the inverse of a
PlanningVariable, which implies it's a shadow
variable.Used via
ServiceLoader so that the constraint streams implementation can be fully split from its API,
without getting split packages or breaking backwards compatibility.THIS CLASS IS EXPERIMENTAL AND UNSUPPORTED.
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.An extension on the
Iterable interface that supports ListIterable.listIterator() and ListIterable.listIterator(int).Swaps two elements of a
list variable.A listener sourced on a
PlanningListVariable.Tracks variable listener events for a given
PlanningListVariable.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.
Determines how
ScoreDirector.lookUpWorkingObject(Object) maps
a problem fact or a planning entity
from an external copy to the internal one.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.Bridges a
MoveIteratorFactory to a MoveSelector.Bridges a
MoveListFactory to a MoveSelector.Generates
Moves.General superclass for
ChangeMoveSelectorConfig, etc.A list that delegates get and set operations to multiple delegates.
A mutable key-value tuple.
Implementations are expected to be stateless.
Specifies that a bean property (or a field) references the next element in the same
PlanningListVariable.Makes no changes.
Makes no changes.
A
NoChangePhase is a Phase which does nothing.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.Represents a predicate (boolean-valued function) of five arguments.
A phase of a
Solver.An adapter for
PhaseLifecycleListener.Internal API.
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.Filters out entities that return true for the
PlanningPin annotated boolean member.Decides on accepting or discarding a
PlanningEntity.Specifies that the class is a planning entity.
Workaround for annotation limitation in
PlanningEntity.difficultyComparatorClass().Workaround for annotation limitation in
PlanningEntity.difficultyWeightFactoryClass().Workaround for annotation limitation in
PlanningEntity.pinningFilter() ()}.Specifies that a property (or a field) on a
PlanningSolution class is a Collection of planning entities.Specifies that a property (or a field) on a
PlanningSolution class is a planning entity.Specifies that a bean property (or a field) can be changed and should be optimized by the optimization algorithms.
Specifies that a boolean property (or field) of a
PlanningEntity determines if the planning entity 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().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 reference to a genuine
PlanningVariable or a shadow variable.Workaround for annotation limitation in
PlanningVariableReference.entityClass().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.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 produces a result.
Created with
Joiners.Represents a predicate (boolean-valued function) of four arguments.
An immutable tuple of four values.
Defines the pseudo random number generator.
Represents the result of the Recommended Fit API,
see
SolutionManager.recommendFit(Object, Object, Function).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.
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.Builds a
ScoreDirector.All
ScoreDirectorFactory implementations must provide an implementation of this interface,
as well as an entry in META-INF/services/ai.timefold.solver.core.impl.score.director.ScoreDirectorFactoryService file.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.
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().Serves for detecting shadow variables' corruption.
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.
A Solver solves a planning problem and returns the best solution found.
To read it from XML, use
SolverConfig.createFromXmlResource(String).Internal API.
Creates
Solver instances.Represents a
problem that has been submitted to solve on the SolverManager.An adapter for
SolverLifecycleListener.A SolverManager solves multiple planning problems of the same domain,
asynchronously without blocking the calling thread.
The status of
problem submitted to the SolverManager.Used to externalize data for a
Supply from the domain model itself.A
SolverStatistic that has no state or event listenerDetermines 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.
Also known as a 2-opt move.
Also known as a 2-opt move selector.
Also known as a 2-opt move selector config.
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.An immutable tuple of three values.
Represents a predicate (boolean-valued function) of three arguments.
Only selects values from the child value selector that are unassigned.
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
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.Factory for
ValueRange.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 a values for a
PlanningVariable.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.
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).Sorts a selection
List based on a SelectionSorterWeightFactory.
IBendableScoreinstead.