Changeset 4067

Timestamp:

Dec 14, 2007, 4:48:18 PM (16 years ago)

Author:

Martin Svensson

Message:

References #762 Updated PropertyFilter? class to use the new operators.

File:

• trunk/src/core/net/sf/basedb/core/PropertyFilter.java (modified) (4 diffs)

trunk/src/core/net/sf/basedb/core/PropertyFilter.java

@@ -26 +26 @@
 package net.sf.basedb.core;
 
+import java.util.ArrayList;
 import java.util.Date;
+import java.util.List;
 
 import net.sf.basedb.core.data.PropertyFilterData;
@@ -180 +182 @@
   {
     return valueType.parseString(value);
+  }
+  
+  /**
+    Splits the value string at each "|" and creates
+    a list with objects from the substrings that were found.
+    @return A list with objects.
+    @throws InvalidDataException If any of the string values can't be parsed.
+    @sine 2.5 
+   */
+  public List<Object> getValuesAsObjects()
+  {
+    String[] values = value.split("|");
+    List<Object> objects = new ArrayList<Object>(values.length);
+    for (String v : values)
+    {
+      objects.add(valueType.parseString(v));
+    }
+    return objects;
   }
   
@@ -232 +252 @@
       boolean searchInherited = property.startsWith("##");
       int annotationTypeId = (Integer)Type.INT.parseString(property.substring(searchInherited ? 2 : 1));
-      restriction = new AnnotationSimpleRestriction(alias, annotationTypeId, getValueType(), 
-        getOperator(), getValueAsObject(), searchInherited);
+      if (operator.isListOperator())
+      {
+        
+      }
+      else
+      {
+        restriction = new AnnotationSimpleRestriction(alias, annotationTypeId, getValueType(), 
+            getOperator(), getValueAsObject(), searchInherited);
+      }
     }
     else
@@ -252 +279 @@
         if (getValueType() == Type.DATE)
         {
-          // To use ==, != and <= filter on dates we must add 24 hours to it
-          // and use different restrictions
-          Date filter = (Date)getValueAsObject();
-          Date filterPlus24H = new Date(filter.getTime()+24*3600*1000);
-          Expression parameterPlus24H = 
-            Expressions.parameter(parameterName+"24h", filterPlus24H, Type.DATE);
-          if (operator == Operator.EQ)
+          if (!operator.isListOperator())
           {
-            // date <= property < date + 24H
-            restriction = Restrictions.between(propertyExpression, parameter, parameterPlus24H);
+            // To use ==, != and <= filter on dates we must add 24 hours to it
+            // and use different restrictions
+            Date filter = (Date)getValueAsObject();
+            Date filterPlus24H = new Date(filter.getTime()+24*3600*1000);
+            Expression parameterPlus24H = 
+              Expressions.parameter(parameterName+"24h", filterPlus24H, Type.DATE);
+            if (operator == Operator.EQ)
+            {
+              // date <= property < date + 24H
+              restriction = Restrictions.between(propertyExpression, parameter, parameterPlus24H);
+            }
+            else if (operator == Operator.NEQ)
+            {
+              // NOT date <= property < date + 24H
+              restriction = Restrictions.not(Restrictions.between(propertyExpression, parameter, parameterPlus24H));
+            }
+            else if (operator == Operator.LTEQ)
+            {
+              // property < date + 24H
+              restriction = Restrictions.lt(propertyExpression, parameterPlus24H);
+            }
+            else if (operator == Operator.GT)
+            {
+              // property >= date + 24H
+              restriction = Restrictions.gteq(propertyExpression, parameterPlus24H);
+            }
           }
-          else if (operator == Operator.NEQ)
+          else 
           {
-            // NOT date <= property < date + 24H
-            restriction = Restrictions.not(Restrictions.between(propertyExpression, parameter, parameterPlus24H));
+            List<Object> objects = getValuesAsObjects();
+            List<Restriction> restrictions = new ArrayList<Restriction>(objects.size());
+            for (Object obj : objects)
+            {
+              Date filter = (Date)obj;
+              Date filterPlus24H = new Date(filter.getTime()+24*3600*1000);
+              parameterName = "p" + System.identityHashCode(obj);
+              Expression parameterPlus24H = 
+                  Expressions.parameter(parameterName+"24h", filterPlus24H, Type.DATE);
+              Expression dateParameter = Expressions.parameter(parameterName, obj, getValueType());
+              if (operator == Operator.IN)
+              {
+                restrictions.add(Restrictions.between(propertyExpression, dateParameter, parameterPlus24H));
+              }
+              else if (operator == Operator.NOTIN)
+              {
+                restrictions.add(Restrictions.not(Restrictions.between(propertyExpression, dateParameter, parameterPlus24H)));
+              }
+            }
+            restriction = Restrictions.or(restrictions.toArray(new Restriction[restrictions.size()]));
           }
-          else if (operator == Operator.LTEQ)
-          {
-            // property < date + 24H
-            restriction = Restrictions.lt(propertyExpression, parameterPlus24H);
-          }
-          else if (operator == Operator.GT)
-          {
-            // property >= date + 24H
-            restriction = Restrictions.gteq(propertyExpression, parameterPlus24H);
-          }
+          
         }
         if (restriction == null)
         {
-          restriction = operator.getRestriction(propertyExpression, parameter);
+          if (operator.isListOperator())
+          {
+            List<Expression> parameters = new ArrayList<Expression>();
+            List<Object> objects = getValuesAsObjects();
+            for (Object obj : objects)
+            {
+              parameterName = "p" + System.identityHashCode(obj);
+              parameters.add(Expressions.parameter(parameterName, obj, getValueType()));
+            }
+            restriction = operator.getRestriction(propertyExpression, parameters.toArray(new Expression[parameters.size()]));
+          }
+          else
+          {
+            restriction = operator.getRestriction(propertyExpression, parameter);
+          }
         }
       }