package org.apache.torque.criteria;
   
   /*
    * Licensed to the Apache Software Foundation (ASF) under one
    * or more contributor license agreements.  See the NOTICE file
    * distributed with this work for additional information
    * regarding copyright ownership.  The ASF licenses this file
    * to you under the Apache License, Version 2.0 (the
    * "License"); you may not use this file except in compliance
   * with the License.  You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing,
   * software distributed under the License is distributed on an
   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
   * KIND, either express or implied.  See the License for the
   * specific language governing permissions and limitations
   * under the License.
   */
  
  import java.io.Serializable;
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.List;
  
  import org.apache.commons.lang.builder.EqualsBuilder;
  import org.apache.commons.lang.builder.HashCodeBuilder;
  import org.apache.torque.Column;
  
  /**
   * Describes one or more where clause parts in the Criteria.
   * Either the parts list is not null and represents this criterion
   * or the column, value, comparison and ignoreStringCase columns
   * are not null and represent this criterion.
   */
  public class Criterion implements Serializable
  {
      /** Serial version. */
      private static final long serialVersionUID = 7157097965404611710L;
  
      /** Constant for the operator " AND ". */
      public static final String AND = " AND ";
  
      /** Constant for the operator " OR ". */
      public static final String OR = " OR ";
  
      /**
       * Left-hand-side value of the comparison, may be null.
       * If this object implements the Column interface, it is interpreted as
       * a value computed by the database, otherwise as verbatim value.
       */
      private Object lValue;
  
      /** Comparison operator. Can only be null if sql is not null. */
      private SqlEnum comparison;
  
      /**
       * Right-hand-side value of the comparison, may be null.
       * If this object implements the Column interface, it is interpreted as
       * a value computed by the database, otherwise as verbatim value.
       */
      private Object rValue;
  
      /** A verbatim SQL for this Criterion. */
      private String sql;
  
      /**
       * Replacements for the placeholders in the verbatim SQL.
       * Is only used if sql is not null.
       */
      private Object[] preparedStatementReplacements;
  
      /** Flag to ignore case in comparison */
      private boolean ignoreCase = false;
  
      /**
       * The criterion objects which form a composite criterion.
       * Either this list is not null and represents this criterion
       * or the column, value, comparison and ignoreStringCase columns
       * are not null and represent this criterion.
       */
      private List<Criterion> parts;
  
      /**
       * The operator (AND, OR...) how the composite criterions
       * are connected.
       */
      private String conjunction;
  
  
      /**
       * Create a new instance.
       * Either this Criterion represents a comparison without verbatim SQL;
       * in this case the parameters lValue and comparison must be not null,
       * rValue may be not null and sql and preparedStatementReplacements must
       * be null; or it represents a verbatim sql condition, in which case
       * the parameter comparison must be null and the sql must be not null
       * (preparedStatementReplacements may be set to contain sql placeholder
      * replacement values, and lValue and rValue can be set to add columns
      * to the automatically computed from clause of the query).
      *
      * @param lValue the left hand side value of the comparison.
      *        If this value should be a value from the database,
      *        the object must implement the
      *        <code>org.apache.torque.Column</code> interface.
      * @param rValue the right hand side value of the comparison.
      *        If this value should be a value from the database,
      *        the object must implement the
      *        <code>org.apache.torque.Column</code> interface.
      * @param comparison The comparison operator. Either this parameter or
      *        sql must be not null.
      * @param sql a verbatim sql condition. Either this parameter or
      *        comparison must be not null.
      * @param preparedStatementReplacements Values for the placeholders
      *        in the verbatim sql condition.
      *
      * @throws NullPointerException if column is null.
      */
     public Criterion(
             Object lValue,
             Object rValue,
             SqlEnum comparison,
             String sql,
             Object[] preparedStatementReplacements)
     {
         if (comparison != null
                 && (sql != null || preparedStatementReplacements != null))
         {
             throw new IllegalArgumentException("Either comparison or "
                     + "some of (sql, preparedStatementReplacements) "
                     + "can be not null, not both");
         }
         if ((lValue == null || comparison == null)
                 && (sql == null))
         {
             throw new IllegalArgumentException("Either the values"
                     + "(lValue, comparison) or "
                     + "sql must be not null");
         }
         this.lValue = lValue;
         this.comparison = comparison;
         this.rValue = rValue;
         this.sql = sql;
         this.preparedStatementReplacements = preparedStatementReplacements;
     }
 
     /**
      * Create a new instance without verbatim sql, using equals as
      * comparison operator.
      *
      * @param lValue the left hand side value of the comparison, not null.
      *        If this value should be a value from the database,
      *        the object must implement the
      *        <code>org.apache.torque.Column</code> interface.
      * @param rValue the right hand side value of the comparison.
      *        If this value should be a value from the database,
      *        the object must implement the
      *        <code>org.apache.torque.Column</code> interface.
      */
     public Criterion(Object lValue, Object rValue)
     {
         this(lValue, rValue, Criteria.EQUAL, null, null);
     }
 
     /**
      * Create a new instance without verbatim sql.
      *
      * @param lValue the left hand side value of the comparison, not null.
      *        If this value should be a value from the database,
      *        the object must implement the
      *        <code>org.apache.torque.Column</code> interface.
      * @param rValue the right hand side value of the comparison.
      *        If this value should be a value from the database,
      *        the object must implement the
      *        <code>org.apache.torque.Column</code> interface.
      * @param comparison The comparison operator, not null.
      */
     public Criterion(Object lValue, Object rValue, SqlEnum comparison)
     {
         this(lValue, rValue, comparison, null, null);
     }
 
     /**
      * Creates a shallow copy of the given Criterion.
      *
      * @param toCopy the Criterion to copy from, not null.
      */
     public Criterion(Criterion toCopy)
     {
         this.lValue = toCopy.lValue;
         this.comparison = toCopy.comparison;
         this.rValue = toCopy.rValue;
         this.sql = toCopy.sql;
         this.preparedStatementReplacements
                 = toCopy.preparedStatementReplacements;
         this.ignoreCase = toCopy.ignoreCase;
         this.parts = toCopy.parts;
         this.conjunction = toCopy.conjunction;
     }
 
     /**
      * Get the left hand side value of the comparison.
      *
      * @return the left hand side value of the comparison.
      *         If this value is a value computed by the database,
      *         the object implements the
      *         <code>org.apache.torque.Column</code> interface.
      */
     public Object getLValue()
     {
         return this.lValue;
     }
 
     /**
      * Set the left hand side value of the comparison.
      *
      * @param lValue the left hand side value of the comparison.
      *        If this value is a value computed by the database,
      *        the object must implement the
      *        <code>org.apache.torque.Column</code> interface.
      */
     public void setLValue(Object lValue)
     {
         this.lValue = lValue;
     }
 
     /**
      * Get the comparison.
      *
      * @return A String with the comparison, or null if this
      *         Criterion represents a verbatim sql condition.
      */
     public SqlEnum getComparison()
     {
         return this.comparison;
     }
 
     /**
      * Get the right hand side value of the comparison.
      *
      * @return the right hand side value of the comparison.
      *         If this value is a value computed by the database,
      *         the object implements the
      *         <code>org.apache.torque.Column</code> interface.
      */
     public Object getRValue()
     {
         return this.rValue;
     }
 
     /**
      * Set the right hand side value of the comparison.
      *
      * @param rValue the right hand side value of the comparison.
      *         If this value is a value computed by the database,
      *         the object must implement the
      *         <code>org.apache.torque.Column</code> interface.
      */
     public void setRValue(Object rValue)
     {
         this.rValue = rValue;
     }
 
     /**
      * Returns the verbatim sql for this condition.
      *
      * @return the verbatim sql for this condition, or null if this
      *         Criterion does not represent a verbatim sql condition.
      */
     public String getSql()
     {
         return sql;
     }
 
     /**
      * Returns the prepared statement replacements for a verbatim sql condition.
      *
      * @return the replacement values, or null.
      */
     public Object[] getPreparedStatementReplacements()
     {
         return preparedStatementReplacements;
     }
 
     /**
      * Returns whether this Criterion represents a verbatim sql condition.
      *
      * @return true if  this Criterion represents a verbatim sql condition,
      *         false if the sql is computed from lValue, comparison and rValue.
      */
     public boolean isVerbatimSqlCondition()
     {
         return (sql != null);
     }
 
     /**
      * Sets ignore case. ignoreCase is ignored for a verbatim sql statement.
      *
      * @param b True if case should be ignored.
      * @return A modified Criterion object.
      */
     public Criterion setIgnoreCase(boolean b)
     {
         ignoreCase = b;
         return this;
     }
 
     /**
      * Is ignore case on or off?
      *
      * @return True if case is ignored.
      */
     public boolean isIgnoreCase()
     {
         return ignoreCase;
     }
 
     /**
      * Returns the parts of which this criterion consists.
      *
      * @return an unmodifiable list of the clauses,
      *         or null if this criterion is not a composite criterion.
      */
     public List<Criterion> getParts()
     {
         if (parts == null)
         {
             return null;
         }
         return Collections.unmodifiableList(parts);
     }
 
     /**
      * Returns the conjunction for the parts of this criterion
      *
      * @return the conjunction, or null if this criterion is not a
      *         composite criterion.
      */
     public String getConjunction()
     {
         return conjunction;
     }
 
     /**
      * Returns whether this criterion is a composite criterion.
      *
      * @return true if this criterion is a composite criterion,
      *         false if it represents a single condition.
      */
     public boolean isComposite()
     {
         return parts != null;
     }
 
     /**
      * Replaces this criterion's condition with
      * (this criterion's condition AND criterion).
      *
      * @param criterion the criterion to and with this criterion,
      *        not null.
      */
     public Criterion and(Criterion criterion)
     {
         addCompositeCriterion(criterion, AND);
         return this;
     }
 
     /**
      * Replaces this criterion's condition with
      * (this criterion's condition OR criterion).
      *
      * @param criterion the criterion to and with this criterion,
      *        not null.
      */
     public Criterion or(Criterion criterion)
     {
         addCompositeCriterion(criterion, OR);
         return this;
     }
 
     /**
      * Add a composite criterion to this criterion.
      *
      * @param criterion the criterion to add, not null.
      * @param conjunction the conjunction by which to add the criterion,
      *        not null.
      *
      * @throws NullPointerException if criterion is null.
      */
     private void addCompositeCriterion(
             Criterion criterion,
             String conjunction)
     {
         if (criterion == null)
         {
             throw new NullPointerException("criterion must not be null");
         }
         if (isComposite() && this.conjunction.equals(conjunction))
         {
             parts.add(criterion);
         }
         else
         {
             Criterion copy = new Criterion(this);
             parts = new ArrayList<Criterion>();
             parts.add(copy);
             parts.add(criterion);
             this.conjunction = conjunction;
             this.rValue = null;
             this.comparison = null;
             this.lValue = null;
             this.sql = null;
             this.preparedStatementReplacements = null;
             this.ignoreCase = false;
         }
     }
 
     /**
      * Appends a debug String representation of the Criterion
      * onto the String builder.
      */
     @SuppressWarnings("deprecation")
     public void appendTo(StringBuilder sb)
     {
         if (isComposite())
         {
             boolean first = true;
             for (Criterion part : parts)
             {
                 if (!first)
                 {
                     sb.append(conjunction);
                 }
                 if (part.isComposite())
                 {
                     sb.append('(');
                 }
                 part.appendTo(sb);
                 if (part.isComposite())
                 {
                       sb.append(')');
                 }
                 first = false;
             }
         }
         else
         {
             if (SqlEnum.CUSTOM == comparison)
             {
                 if (rValue != null && !"".equals(rValue))
                 {
                     sb.append((String) rValue);
                 }
             }
             else if (isVerbatimSqlCondition())
             {
                 sb.append(sql);
             }
             else
             {
                 String lValueDisplay;
                 if (lValue instanceof Column)
                 {
                     lValueDisplay = ((Column) lValue).getSqlExpression();
                 }
                 else if (lValue != null)
                 {
                     lValueDisplay = lValue.toString();
                 }
                 else
                 {
                     lValueDisplay = "";
                 }
                 String rValueDisplay;
                 if (rValue instanceof Column)
                 {
                     rValueDisplay = ((Column) rValue).getSqlExpression();
                 }
                 else if (rValue != null)
                 {
                     rValueDisplay = rValue.toString();
                 }
                 else
                 {
                     rValueDisplay = "";
                 }
                 sb.append(lValueDisplay)
                     .append(comparison)
                     .append(rValueDisplay);
             }
         }
     }
 
     /**
      * Build a string representation of the Criterion for debug purposes.
      *
      * @return A String with the representation of the Criterion.
      */
     @Override
     public String toString()
     {
         StringBuilder builder = new StringBuilder();
         appendTo(builder);
         return builder.toString();
     }
 
     /**
      * This method checks another Criteria.Criterion to see if they contain
      * the same attributes.
      */
     @Override
     public boolean equals(Object obj)
     {
         if (this == obj)
         {
             return true;
         }
         if (obj == null)
         {
             return false;
         }
         if (obj.getClass() != this.getClass())
         {
             return false;
         }
 
         Criterion criterion = (Criterion) obj;
         EqualsBuilder equalsBuilder = new EqualsBuilder();
         equalsBuilder.append(criterion.lValue, this.lValue)
                 .append(criterion.comparison, this.comparison)
                 .append(criterion.rValue, this.rValue)
                 .append(criterion.sql, this.sql)
                 .append(criterion.preparedStatementReplacements,
                         this.preparedStatementReplacements)
                 .append(criterion.ignoreCase, this.ignoreCase)
                 .append(criterion.parts, this.parts)
                 .append(criterion.conjunction, this.conjunction);
         return equalsBuilder.isEquals();
     }
 
     /**
      * Returns a hash code value for the object.
      */
     @Override
     public int hashCode()
     {
         HashCodeBuilder hashCodeBuilder = new HashCodeBuilder();
         hashCodeBuilder.append(this.lValue)
                 .append(this.comparison)
                 .append(this.rValue)
                 .append(this.sql)
                 .append(this.preparedStatementReplacements)
                 .append(this.ignoreCase)
                 .append(this.parts)
                 .append(this.conjunction);
         return hashCodeBuilder.toHashCode();
     }
 }