Packages

abstract class DepthFirstStrategy extends RefiningStrategy

Strategies that recursively refine depth-first through arguments and subproblems of problem components. These strategies never visit a component more than once; thus they are not reusable.

Linear Supertypes
RefiningStrategy, AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. DepthFirstStrategy
  2. RefiningStrategy
  3. AnyRef
  4. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Instance Constructors

  1. new DepthFirstStrategy(collection: ComponentCollection)

    collection

    Collection of components to refine.

Abstract Value Members

  1. abstract def checkArg[T](element: Element[T]): ProblemComponent[T]

    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

    Element for which to return a problem component.

    Attributes
    protected
  2. abstract def initialComponents: Traversable[ProblemComponent[_]]

    Initial components to process.

    Initial components to process. Decomposition proceeds in a depth-first fashion from these components.

    returns

    Traversable of components from which to refine initially.

  3. abstract def processChain[P, V](chainComp: ChainComponent[P, V]): Unit

    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.

    chainComp

    Chain component to process. This should not be called on a component we previously processed, including fully refined components.

  4. abstract def processMakeArray[V](maComp: MakeArrayComponent[V]): Unit

    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.

    maComp

    MakeArray component to process. This should not be called on a component we previously processed, including fully refined components.

  5. abstract def shouldRefine(comp: ProblemComponent[_]): Boolean

    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.

    comp

    Component to consider refining.

    returns

    True if and only if this strategy should refine the argument.

    Attributes
    protected

Concrete Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  5. def clone(): AnyRef
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  6. val collection: ComponentCollection
    Definition Classes
    RefiningStrategy
  7. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  8. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  9. def execute(): Unit

    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.

    Definition Classes
    DepthFirstStrategyRefiningStrategy
  10. def finalize(): Unit
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  11. def generateRange(comp: ProblemComponent[_]): Unit

    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.

    comp

    Component to process.

    Definition Classes
    RefiningStrategy
  12. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
  13. def hashCode(): Int
    Definition Classes
    AnyRef → Any
  14. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  15. def markProblemsUnsolved(problems: Set[Problem]): Unit

    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.

    Attributes
    protected
    Definition Classes
    RefiningStrategy
  16. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  17. final def notify(): Unit
    Definition Classes
    AnyRef
  18. final def notifyAll(): Unit
    Definition Classes
    AnyRef
  19. def process[V](comp: ProblemComponent[V]): Unit

    Generate the range for the given component.

    Generate the range for the given component. Mark it as fully refined or enumerated if applicable.

    comp

    Component to process. This should not be called on a component we previously processed, including fully refined components.

  20. def processAtomic[V](atomicComp: AtomicComponent[V]): Unit

    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.

    atomicComp

    Atomic component to process. This should not be called on a component we previously processed, including fully refined components.

  21. def refine(comp: ProblemComponent[_]): Unit

    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.

    comp

    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.

  22. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  23. def toString(): String
    Definition Classes
    AnyRef → Any
  24. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  25. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  26. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

Inherited from RefiningStrategy

Inherited from AnyRef

Inherited from Any

Ungrouped