Coverage Report

Coverage Report - org.kuali.rice.core.api.criteria.CriteriaSupportUtils

Classes in this File

Line Coverage

Branch Coverage

Complexity

CriteriaSupportUtils

77%

71/92

77%

57/74

9.75

CriteriaSupportUtils$PropertyConstants

0/1

N/A

9.75

 /*
  * Copyright 2011 The Kuali Foundation
  *
  * Licensed under the Educational Community License, Version 1.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.opensource.org/licenses/ecl1.php
  *
  * 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.
  */
 package org.kuali.rice.core.api.criteria;
 
 import org.apache.commons.lang.StringUtils;
 
 import javax.xml.bind.annotation.XmlElement;
 import javax.xml.bind.annotation.XmlElements;
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import java.math.BigDecimal;
 import java.math.BigInteger;
 import java.util.Calendar;
 import java.util.Collections;
 import java.util.Date;
 import java.util.HashSet;
 import java.util.Set;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicLong;
 
 /**
  * A class which includes various utilities and constants for use within the criteria API.
  * This class is intended to be for internal use only within the criteria API.
  * 
  * @author Kuali Rice Team (rice.collab@kuali.org)
  */
 final class CriteriaSupportUtils {
         
         private CriteriaSupportUtils () {}
         
     /**
      * Defines various property constants for internal use within the criteria package.
      */
     static class PropertyConstants {
             
             /**
              * A constant representing the property name for {@link PropertyPathPredicate#getPropertyPath()}
              */
         final static String PROPERTY_PATH = "propertyPath";
         
             /**
              * A constant representing the property name for {@link SingleValuedPredicate#getValue()}
              */
         final static String VALUE = "value";
         
         /**
          * A constant representing the method name for {@link SingleValuedPredicate#getValue()}
          */
         final static String GET_VALUE_METHOD_NAME = "getValue";
 
         /**
              * A constant representing the property name for {@link MultiValuedPredicate#getValues()}
              */
         final static String VALUES = "values";
 
         /**
          * A constant representing the method name for {@link MultiValuedPredicate#getValues()}
          */
         final static String GET_VALUES_METHOD_NAME = "getValues";
     }
 
     /**
      * Validates the various properties of a {@link SingleValuedPredicate}.
      * 
      * @param valuedPredicateClass the type of the predicate
      * @param propertyPath the propertyPath which is being configured on the predicate
      * @param value the value which is being configured on the predicate
      * 
      * @throws IllegalArgumentException if the propertPath is null or blank
      * @throws IllegalArgumentException if the value is null
      * @throws IllegalArgumentException if the given {@link SingleValuedPredicate} class does not support the {@link CriteriaValue}
      */
     static void validateValuedConstruction(Class<? extends SingleValuedPredicate> valuedPredicateClass, String propertyPath, CriteriaValue<?> value) {
             if (StringUtils.isBlank(propertyPath)) {
                         throw new IllegalArgumentException("Property path cannot be null or blank.");
                 }
                 if (value == null) {
                     throw new IllegalArgumentException("CriteriaValue cannot be null.");
                 }
                 if (!CriteriaSupportUtils.supportsCriteriaValue(valuedPredicateClass, value)) {
                     throw new IllegalArgumentException(valuedPredicateClass.getSimpleName() + " does not support the given CriteriaValue");
                 }
     }
 
         static boolean supportsCriteriaValue(Class<? extends SingleValuedPredicate> simplePredicateClass, CriteriaValue<?> value) {
             if (simplePredicateClass == null) {
                 throw new IllegalArgumentException("simplePredicateClass was null");
             }
             if (value == null) {
                 throw new IllegalArgumentException("valueClass was null");
             }
             XmlElements elementsAnnotation = CriteriaSupportUtils.findXmlElementsAnnotation(simplePredicateClass);
             if (elementsAnnotation != null) {
                 XmlElement[] elements = elementsAnnotation.value();
                 for (XmlElement element : elements) {
                     if (value.getClass().equals(element.type())) {
                         return true;
                     }
                 }
             }
             return false;
         }
         
         private static XmlElements findXmlElementsAnnotation(Class<?> simplePredicateClass) {
                 if (simplePredicateClass != null) {
                         try{
                                 Field valueField = simplePredicateClass.getDeclaredField(PropertyConstants.VALUE);
                                 XmlElements elementsAnnotation = valueField.getAnnotation(XmlElements.class);
                                 if (elementsAnnotation != null) {
                                         return elementsAnnotation;
                                 }
                         } catch (NoSuchFieldException e) {
                                 // ignore, try the method
                         }
                         try {
                                 Method valueMethod = simplePredicateClass.getDeclaredMethod(PropertyConstants.GET_VALUE_METHOD_NAME, (Class<?>[])null);
                                 XmlElements elementsAnnotation = valueMethod.getAnnotation(XmlElements.class);
                                 if (elementsAnnotation == null) {
                                         return CriteriaSupportUtils.findXmlElementsAnnotation(simplePredicateClass.getSuperclass());
                                 }
                                 return elementsAnnotation;
                         } catch (NoSuchMethodException e) {
                                 return CriteriaSupportUtils.findXmlElementsAnnotation(simplePredicateClass.getSuperclass());
                         }
                 }
                 return null;
         }
         
         static CriteriaValue<?> determineCriteriaValue(Object object) {
                 if (object == null) {
                         throw new IllegalArgumentException("Given criteria value cannot be null.");
                 } else if (object instanceof CharSequence) {
                         return new CriteriaStringValue((CharSequence)object);
                 } else if (object instanceof Calendar) {
                         return new CriteriaDateTimeValue((Calendar)object);
                 } else if (object instanceof Date) {
                         return new CriteriaDateTimeValue((Date)object);
                 } else if (object instanceof BigInteger) {
                         return new CriteriaIntegerValue((BigInteger)object);
                 } else if (object instanceof Short) {
                         return new CriteriaIntegerValue((Short)object);
                 } else if (object instanceof Integer) {
                         return new CriteriaIntegerValue((Integer)object);
                 } else if (object instanceof AtomicInteger) {
                         return new CriteriaIntegerValue((AtomicInteger)object);
                 } else if (object instanceof Long) {
                         return new CriteriaIntegerValue((Long)object);
                 } else if (object instanceof AtomicLong) {
                         return new CriteriaIntegerValue((AtomicLong)object);
                 } else if (object instanceof BigDecimal) {
                         return new CriteriaDecimalValue((BigDecimal)object);
                 } else if (object instanceof Float) {
                         return new CriteriaDecimalValue((Float)object);
                 } else if (object instanceof Double) {
                         return new CriteriaDecimalValue((Double)object);
                 }
                 throw new IllegalArgumentException("Failed to translate the given object to a CriteriaValue: " + object);
         }
         
         static Set<CriteriaValue<?>> determineCriteriaValueList(Object[] values) {
                 if (values == null) {
                         return null;
                 } else if (values.length == 0) {
                         return Collections.emptySet();
                 }
                 Set<CriteriaValue<?>> criteriaValues = new HashSet<CriteriaValue<?>>();
                 for (Object value : values) {
                         if (value != null) {
                 criteriaValues.add(determineCriteriaValue(value));
             }
                 }
                 return criteriaValues;
         }
 
     static Set<CriteriaStringValue> createCriteriaStringValueList(CharSequence[] values) {
                 if (values == null) {
                         return null;
                 } else if (values.length == 0) {
                         return Collections.emptySet();
                 }
                 Set<CriteriaStringValue> criteriaValues = new HashSet<CriteriaStringValue>();
                 for (CharSequence value : values) {
                         if (value != null) {
                 criteriaValues.add(new CriteriaStringValue(value));
             }
                 }
                 return criteriaValues;
         }
         
         /**
      * Validates the incoming list of CriteriaValue to ensure they are valid for a
      * {@link MultiValuedPredicate}.  To be valid, the following must be true:
      * 
      * <ol>
      *   <li>The list of values must not be null.</li>
      *   <li>The list of values must not be empty.</li>
      *   <li>The list of values must all be of the same parameterized {@link CriteriaValue} type.</li>
      * </ol>
      */
     static void validateValuesForMultiValuedPredicate(Set<? extends CriteriaValue<?>> values) {
             if (values == null) {
                     throw new IllegalArgumentException("Criteria values cannot be null.");
             } else if (values.isEmpty()) {
                     throw new IllegalArgumentException("Criteria values cannot be empty.");
             }
             Class<?> previousType = null;
             for (CriteriaValue<?> value : values) {
                     Class<?> currentType = value.getClass();
                     if (previousType != null) {
                             if (!currentType.equals(previousType)) {
                                     throw new IllegalArgumentException("Encountered criteria values which do not match.  One was: " + previousType + " the other was: " + currentType);
                             }
                     }
                     previousType = currentType;
             }
     }
         
 }

1		/*
2		* Copyright 2011 The Kuali Foundation
3		*
4		* Licensed under the Educational Community License, Version 1.0 (the "License");
5		* you may not use this file except in compliance with the License.
6		* You may obtain a copy of the License at
7		*
8		* http://www.opensource.org/licenses/ecl1.php
9		*
10		* Unless required by applicable law or agreed to in writing, software
11		* distributed under the License is distributed on an "AS IS" BASIS,
12		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13		* See the License for the specific language governing permissions and
14		* limitations under the License.
15		*/
16		package org.kuali.rice.core.api.criteria;
17
18		import org.apache.commons.lang.StringUtils;
19
20		import javax.xml.bind.annotation.XmlElement;
21		import javax.xml.bind.annotation.XmlElements;
22		import java.lang.reflect.Field;
23		import java.lang.reflect.Method;
24		import java.math.BigDecimal;
25		import java.math.BigInteger;
26		import java.util.Calendar;
27		import java.util.Collections;
28		import java.util.Date;
29		import java.util.HashSet;
30		import java.util.Set;
31		import java.util.concurrent.atomic.AtomicInteger;
32		import java.util.concurrent.atomic.AtomicLong;
33
34		/**
35		* A class which includes various utilities and constants for use within the criteria API.
36		* This class is intended to be for internal use only within the criteria API.
37		*
38		* @author Kuali Rice Team (rice.collab@kuali.org)
39		*/
40		final class CriteriaSupportUtils {
41
42	0	private CriteriaSupportUtils () {}
43
44		/**
45		* Defines various property constants for internal use within the criteria package.
46		*/
47	0	static class PropertyConstants {
48
49		/**
50		* A constant representing the property name for {@link PropertyPathPredicate#getPropertyPath()}
51		*/
52		final static String PROPERTY_PATH = "propertyPath";
53
54		/**
55		* A constant representing the property name for {@link SingleValuedPredicate#getValue()}
56		*/
57		final static String VALUE = "value";
58
59		/**
60		* A constant representing the method name for {@link SingleValuedPredicate#getValue()}
61		*/
62		final static String GET_VALUE_METHOD_NAME = "getValue";
63
64		/**
65		* A constant representing the property name for {@link MultiValuedPredicate#getValues()}
66		*/
67		final static String VALUES = "values";
68
69		/**
70		* A constant representing the method name for {@link MultiValuedPredicate#getValues()}
71		*/
72		final static String GET_VALUES_METHOD_NAME = "getValues";
73		}
74
75		/**
76		* Validates the various properties of a {@link SingleValuedPredicate}.
77		*
78		* @param valuedPredicateClass the type of the predicate
79		* @param propertyPath the propertyPath which is being configured on the predicate
80		* @param value the value which is being configured on the predicate
81		*
82		* @throws IllegalArgumentException if the propertPath is null or blank
83		* @throws IllegalArgumentException if the value is null
84		* @throws IllegalArgumentException if the given {@link SingleValuedPredicate} class does not support the {@link CriteriaValue}
85		*/
86		static void validateValuedConstruction(Class<? extends SingleValuedPredicate> valuedPredicateClass, String propertyPath, CriteriaValue<?> value) {
87	118	if (StringUtils.isBlank(propertyPath)) {
88	14	throw new IllegalArgumentException("Property path cannot be null or blank.");
89		}
90	104	if (value == null) {
91	1	throw new IllegalArgumentException("CriteriaValue cannot be null.");
92		}
93	103	if (!CriteriaSupportUtils.supportsCriteriaValue(valuedPredicateClass, value)) {
94	6	throw new IllegalArgumentException(valuedPredicateClass.getSimpleName() + " does not support the given CriteriaValue");
95		}
96	97	}
97
98		static boolean supportsCriteriaValue(Class<? extends SingleValuedPredicate> simplePredicateClass, CriteriaValue<?> value) {
99	112	if (simplePredicateClass == null) {
100	2	throw new IllegalArgumentException("simplePredicateClass was null");
101		}
102	110	if (value == null) {
103	1	throw new IllegalArgumentException("valueClass was null");
104		}
105	109	XmlElements elementsAnnotation = CriteriaSupportUtils.findXmlElementsAnnotation(simplePredicateClass);
106	109	if (elementsAnnotation != null) {
107	109	XmlElement[] elements = elementsAnnotation.value();
108	184	for (XmlElement element : elements) {
109	177	if (value.getClass().equals(element.type())) {
110	102	return true;
111		}
112		}
113		}
114	7	return false;
115		}
116
117		private static XmlElements findXmlElementsAnnotation(Class<?> simplePredicateClass) {
118	109	if (simplePredicateClass != null) {
119		try{
120	109	Field valueField = simplePredicateClass.getDeclaredField(PropertyConstants.VALUE);
121	109	XmlElements elementsAnnotation = valueField.getAnnotation(XmlElements.class);
122	109	if (elementsAnnotation != null) {
123	109	return elementsAnnotation;
124		}
125	0	} catch (NoSuchFieldException e) {
126		// ignore, try the method
127	0	}
128		try {
129	0	Method valueMethod = simplePredicateClass.getDeclaredMethod(PropertyConstants.GET_VALUE_METHOD_NAME, (Class<?>[])null);
130	0	XmlElements elementsAnnotation = valueMethod.getAnnotation(XmlElements.class);
131	0	if (elementsAnnotation == null) {
132	0	return CriteriaSupportUtils.findXmlElementsAnnotation(simplePredicateClass.getSuperclass());
133		}
134	0	return elementsAnnotation;
135	0	} catch (NoSuchMethodException e) {
136	0	return CriteriaSupportUtils.findXmlElementsAnnotation(simplePredicateClass.getSuperclass());
137		}
138		}
139	0	return null;
140		}
141
142		static CriteriaValue<?> determineCriteriaValue(Object object) {
143	100	if (object == null) {
144	8	throw new IllegalArgumentException("Given criteria value cannot be null.");
145	92	} else if (object instanceof CharSequence) {
146	41	return new CriteriaStringValue((CharSequence)object);
147	51	} else if (object instanceof Calendar) {
148	6	return new CriteriaDateTimeValue((Calendar)object);
149	45	} else if (object instanceof Date) {
150	5	return new CriteriaDateTimeValue((Date)object);
151	40	} else if (object instanceof BigInteger) {
152	0	return new CriteriaIntegerValue((BigInteger)object);
153	40	} else if (object instanceof Short) {
154	1	return new CriteriaIntegerValue((Short)object);
155	39	} else if (object instanceof Integer) {
156	30	return new CriteriaIntegerValue((Integer)object);
157	9	} else if (object instanceof AtomicInteger) {
158	0	return new CriteriaIntegerValue((AtomicInteger)object);
159	9	} else if (object instanceof Long) {
160	1	return new CriteriaIntegerValue((Long)object);
161	8	} else if (object instanceof AtomicLong) {
162	0	return new CriteriaIntegerValue((AtomicLong)object);
163	8	} else if (object instanceof BigDecimal) {
164	8	return new CriteriaDecimalValue((BigDecimal)object);
165	0	} else if (object instanceof Float) {
166	0	return new CriteriaDecimalValue((Float)object);
167	0	} else if (object instanceof Double) {
168	0	return new CriteriaDecimalValue((Double)object);
169		}
170	0	throw new IllegalArgumentException("Failed to translate the given object to a CriteriaValue: " + object);
171		}
172
173		static Set<CriteriaValue<?>> determineCriteriaValueList(Object[] values) {
174	17	if (values == null) {
175	2	return null;
176	15	} else if (values.length == 0) {
177	2	return Collections.emptySet();
178		}
179	13	Set<CriteriaValue<?>> criteriaValues = new HashSet<CriteriaValue<?>>();
180	41	for (Object value : values) {
181	28	if (value != null) {
182	28	criteriaValues.add(determineCriteriaValue(value));
183		}
184		}
185	13	return criteriaValues;
186		}
187
188		static Set<CriteriaStringValue> createCriteriaStringValueList(CharSequence[] values) {
189	4	if (values == null) {
190	0	return null;
191	4	} else if (values.length == 0) {
192	0	return Collections.emptySet();
193		}
194	4	Set<CriteriaStringValue> criteriaValues = new HashSet<CriteriaStringValue>();
195	16	for (CharSequence value : values) {
196	12	if (value != null) {
197	12	criteriaValues.add(new CriteriaStringValue(value));
198		}
199		}
200	4	return criteriaValues;
201		}
202
203		/**
204		* Validates the incoming list of CriteriaValue to ensure they are valid for a
205		* {@link MultiValuedPredicate}. To be valid, the following must be true:
206		*
207		* <ol>
208		* <li>The list of values must not be null.</li>
209		* <li>The list of values must not be empty.</li>
210		* <li>The list of values must all be of the same parameterized {@link CriteriaValue} type.</li>
211		* </ol>
212		*/
213		static void validateValuesForMultiValuedPredicate(Set<? extends CriteriaValue<?>> values) {
214	53	if (values == null) {
215	4	throw new IllegalArgumentException("Criteria values cannot be null.");
216	49	} else if (values.isEmpty()) {
217	4	throw new IllegalArgumentException("Criteria values cannot be empty.");
218		}
219	45	Class<?> previousType = null;
220	45	for (CriteriaValue<?> value : values) {
221	125	Class<?> currentType = value.getClass();
222	125	if (previousType != null) {
223	80	if (!currentType.equals(previousType)) {
224	2	throw new IllegalArgumentException("Encountered criteria values which do not match. One was: " + previousType + " the other was: " + currentType);
225		}
226		}
227	123	previousType = currentType;
228	123	}
229	43	}
230
231		}