Package oracle.webcenter.search.refine

Class Refinement<T>

java.lang.Object
oracle.webcenter.search.refine.Refinement<T>
All Implemented Interfaces:
Serializable, Cloneable
Direct Known Subclasses:
DateRefinement, StringRefinement
@Exported public abstract class Refinement<T> extends Object implements Cloneable, Serializable
An abstract base class for Refinements in general. Refinements are used to refine a Predicate and are part of a Refiner that act on a particular column specified by a QName.
Since:
11.1.1.0.0 Beta 2
See Also:

  • Nested Class Summary

    Nested Classes
    Modifier and Type
    Class
    Description
    static class 
    Refinement.Clause<T>
    The Clause class describes a clause within a Refinement, which can have one or more clauses.

  • Constructor Summary

    Constructors
    Modifier
    Constructor
    Description
    protected
    Refinement(List<Refinement.Clause<T>> clauses, int count)
    Creates a Refinement with a List of Refinement.Clause objects and a count of how many results are expected to return these clauses are applied.
    protected
    Refinement(T value, int count)
    Creates a Refinement with a value of type T and a count of how many results applying this Refinement will be expected to return.
    protected
    Refinement(T value, String comparator, int count)
    Creates a Refinement with a value of type T a comparator, and a count of how many results applying this Refinement will be expected to return.

  • Method Summary

    Modifier and Type
    Method
    Description
    protected void
    addAttributePredicate(List<Predicate> children, AttributePredicate<T> newPredicate)
    Subclasses should normalize the list of AttributePredicate<T> by overriding this method.
    protected void
    buildName(List<Refinement.Clause<T>> clauses)
    Delegate to subclasses to build the name of the Refinement given a list of clauses.
    protected void
    buildName(Refinement.Clause<T> clause)
    Delegate to subclasses to build the name of the Refinement given a clause.
    protected abstract void
    buildName(T value)
    Let the subclass build the name based on a type T that the subclass will know.
    protected AttributePredicate<T>
    createPredicate(QName name, String comparator, T value)
     
    protected List<Refinement.Clause<T>>
    getClauses()
    Returns the list of clauses held within this Refinement.
    abstract ComplexPredicate.ConjunctionOp
    getConjunctionOp()
    Gets the conjunction operator that can be used to chain clauses produced by this Refinement.
    int
    getCount()
    Gets the number of results expected to return when this Refinement is applied.
    String
    getName()
    Gets the display name of this Refinement.
    T
    getValue()
    Gets the value to compare against in the first clause of this Refinement.
    abstract boolean
    hasMatch(T value)
    Different types have different interpretations of hasMatch.
    void
    increment()
    Increment the count of this Refinement.
    void
    increment(int count)
    Increment the count of this Refinement by a certain amount.
    protected List<Refinement.Clause<T>>
    initClauses(T value, String comparator)
     
    boolean
    isCurrent()
    Is this the current refinement?
    void
    refine(Refiner<T> refiner, ComplexPredicate topPredicate)
    Allows for refining a Query object.
    void
    setCount(int count)
    Sets the number of results expected to return when this Refinement is applied.
    void
    setCurrent(boolean value)
    Indicate if this is the current refinement
    void
    setName(String name)
    Sets the display name of the Refinement.
    String
    toString()
     

    Methods inherited from class java.lang.Object

    clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

  • Constructor Details

    • Refinement

      protected Refinement(T value, int count)
      Creates a Refinement with a value of type T and a count of how many results applying this Refinement will be expected to return. This results in a Refinement with one Refinement.Clause testing for EQUALS with the passed in value.
      Parameters:
      value - a value of type T to compare against with an EQUALS comparator value
      count - the number of results expected to return when this Refinement is applied

    • Refinement

      protected Refinement(T value, String comparator, int count)
      Creates a Refinement with a value of type T a comparator, and a count of how many results applying this Refinement will be expected to return. This results in a Refinement with one Refinement.Clause specified by the parameters.
      Parameters:
      value - a value of type T to compare against
      comparator - the String comparator to use for comparison taken from ComparatorConstants
      count - the number of results expected to return when this Refinement is applied

    • Refinement

      protected Refinement(List<Refinement.Clause<T>> clauses, int count)
      Creates a Refinement with a List of Refinement.Clause objects and a count of how many results are expected to return these clauses are applied.
      Parameters:
      clauses - the List of Refinement.Clause objects each representing a comparison
      count - the number of results expected to return when this Refinement is applied

  • Method Details

    • initClauses

      protected List<Refinement.Clause<T>> initClauses(T value, String comparator)

    • getClauses

      protected List<Refinement.Clause<T>> getClauses()
      Returns the list of clauses held within this Refinement.
      Returns:
      a List of Refinement.Clause objects that this Refinement will apply on its subjects

    • buildName

      protected void buildName(List<Refinement.Clause<T>> clauses)
      Delegate to subclasses to build the name of the Refinement given a list of clauses.
      Parameters:
      clauses - the List of Refinement.Clause objects that subclasses can use to build the name of the Refinement

    • buildName

      protected void buildName(Refinement.Clause<T> clause)
      Delegate to subclasses to build the name of the Refinement given a clause.
      Parameters:
      clause - the Refinement.Clause objects that subclasses can use to build the name of the Refinement

    • buildName

      protected abstract void buildName(T value)
      Let the subclass build the name based on a type T that the subclass will know.
      Parameters:
      value - a value of type T that a subclass will use to build the name for the Refinement

    • hasMatch

      public abstract boolean hasMatch(T value)
      Different types have different interpretations of hasMatch. For now assume that the passed in parameter is single.
      Parameters:
      value - a value to match the clauses defined in this class
      Returns:
      true if a match occurs

    • refine

      public void refine(Refiner<T> refiner, ComplexPredicate topPredicate) throws ContradictionException
      Allows for refining a Query object. Most of the time this means adding more predicates.
      Parameters:
      topPredicate - the Predicate object being modified
      refiner - holder of Refinements that may affect the topPredicate
      Throws:
      ContradictionException - when the act of refining causes a contradiction to occur in the ComplexPredicate.

    • createPredicate

      protected AttributePredicate<T> createPredicate(QName name, String comparator, T value)

    • addAttributePredicate

      protected void addAttributePredicate(List<Predicate> children, AttributePredicate<T> newPredicate) throws ContradictionException
      Subclasses should normalize the list of AttributePredicate<T> by overriding this method.
      Parameters:
      children - the children of the top level ComplexPredicate to refine
      newPredicate - the new AttributePredicate<T> to add.
      Throws:
      ContradictionException

    • getConjunctionOp

      public abstract ComplexPredicate.ConjunctionOp getConjunctionOp()
      Gets the conjunction operator that can be used to chain clauses produced by this Refinement.
      Returns:
      a ConjunctionOp that is either ConjunctionOp.And or ConjunctionOp.Or

    • getValue

      public T getValue()
      Gets the value to compare against in the first clause of this Refinement.
      Returns:
      a value of type T to compare against in the first clause

    • getName

      public String getName()
      Gets the display name of this Refinement.
      Returns:
      a String name of this Refinement that was built by buildName

    • setName

      public void setName(String name)
      Sets the display name of the Refinement.
      Parameters:
      name - the name to set

    • getCount

      public int getCount()
      Gets the number of results expected to return when this Refinement is applied.
      Returns:
      an integer that estimates the number of results expected after application

    • setCount

      public void setCount(int count)
      Sets the number of results expected to return when this Refinement is applied.
      Parameters:
      count - an integer that estimates the number of results expected after application

    • increment

      public void increment()
      Increment the count of this Refinement. This method is useful when building Refiners in the RefinerBuilder code.

    • increment

      public void increment(int count)
      Increment the count of this Refinement by a certain amount. This method is useful when building Refiners in the RefinerBuilder code.
      Parameters:
      count - the count to add to the current count

    • setCurrent

      public void setCurrent(boolean value)
      Indicate if this is the current refinement

    • isCurrent

      public boolean isCurrent()
      Is this the current refinement?

    • toString

      public String toString()
      Overrides:
      toString in class Object