com.cra.figaro.algorithm.structured.strategy.refine
TopDownStrategy
Related Docs:
object TopDownStrategy
| package refine
com.cra.figaro.algorithm.structured.strategy.refine
Collection of components to refine.
Components from which to initialize the top-down search for dependent components. Strictly speaking, it is not essential that these components be top-level (i.e. have no args), but most components that are not top-level cannot be refined without first refining their args. It is up to the caller of this constructor to ensure that (1) the components in this set and their arguments already belong to the collection, and (2) that such a call maintains consistency across component ranges.
Get the problem component associated with an element.
Get the problem component associated with an element. This may involve adding the element to the collection if a problem component has not yet been created.
Element for which to return a problem component.
Collection of components to refine.
Collection of components to refine.
Refine in place using this strategy.
Refine in place using this strategy. This will recursively mark as unsolved any problems whose solutions are no longer applicable as a result of refinement. This also marks problem components as fully enumerated or refined where applicable.
Process a component by generating its range, if it is not already fully enumerated.
Process a component by generating its range, if it is not already fully enumerated. After calling this method, it may be necessary to check if the component is fully enumerated or refined.
Component to process.
Components to refine.
Components to refine. Often, this is a set of atomic components and their dependencies. Note that this strategy does not recursively add or update any components not in this set. Thus, it is up to the caller of this constructor to ensure that (1) the components in this set and their arguments already belong to the collection, and (2) that such a call maintains consistency across component ranges.
Recursively marks as unsolved any problem whose solution could have changed as a result of refinement by this strategy or any of its recursively generated strategies.
Recursively marks as unsolved any problem whose solution could have changed as a result of refinement by this strategy or any of its recursively generated strategies.
Generate the range for the given component.
Generate the range for the given component. Mark it as fully refined or enumerated if applicable.
Component to process. This should not be called on a component we previously processed, including fully refined components.
Generate the range for the given atomic component.
Generate the range for the given atomic component. Mark it as fully refined or enumerated if applicable.
Atomic component to process. This should not be called on a component we previously processed, including fully refined components.
Generate the range for the given Chain component.
Generate the range for the given Chain component. Mark it as fully refined or enumerated if applicable.
Chain component to process. This should not be called on a component we previously processed, including fully refined components.
Generate the range for the given MakeArray component.
Generate the range for the given MakeArray component. Mark it as fully refined or enumerated if applicable.
MakeArray component to process. This should not be called on a component we previously processed, including fully refined components.
Refine a single problem component by recursively refining components on which it depends, then generating the range for each component.
Refine a single problem component by recursively refining components on which it depends, then generating the range for each component. This guarantees that when ranges are created, all components on which a component depends will have been processed.
As a rule, this method never works in the other direction. If component B depends (directly or indirectly) on component A, then calling decompose on A will never recursively call decompose on component B. This is to avoid infinite loops, and to guarantee that the range of A does not unpredictably change in the middle of a call to decompose A.
Once the range has been created, the component will be added to the set done, and (if applicable) the component is marked as fully enumerated or refined.
Component to refine. This strategy never refines a component more than once, so if the component is fully refined or in the set done, this method does nothing.
Decide if this strategy should refine the given problem component.
Decide if this strategy should refine the given problem component. This is usually based on the refinement status
of the component and the components on which it depends. This check should not depend on the set done; such a
check is performed separately.
Component to consider refining.
True if and only if this strategy should refine the argument.
Strategies that refine a fixed set of components, as well as all dependent components that are also in the collection.