ComparisonFunctors


1   // ============================================================================
2   // $Id: ComparisonFunctors.java,v 1.4 2006/12/16 16:48:58 davidahall Exp $
3   // Copyright (c) 2006  David A. Hall
4   // ============================================================================
5   // The contents of this file are subject to the Common Development and
6   // Distribution License (CDDL), Version 1.0 (the License); you may not use this 
7   // file except in compliance with the License.  You should have received a copy
8   // of the the License along with this file: if not, a copy of the License is 
9   // available from Sun Microsystems, Inc.
10  //
11  // http://www.sun.com/cddl/cddl.html
12  //
13  // From time to time, the license steward (initially Sun Microsystems, Inc.) may
14  // publish revised and/or new versions of the License.  You may not use,  
15  // distribute, or otherwise make this file available under subsequent versions 
16  // of the License.
17  // 
18  // Alternatively, the contents of this file may be used under the terms of the 
19  // GNU Lesser General Public License Version 2.1 or later (the "LGPL"), in which
20  // case the provisions of the LGPL are applicable instead of those above. If you 
21  // wish to allow use of your version of this file only under the terms of the 
22  // LGPL, and not to allow others to use your version of this file under the 
23  // terms of the CDDL, indicate your decision by deleting the provisions above 
24  // and replace them with the notice and other provisions required by the LGPL. 
25  // If you do not delete the provisions above, a recipient may use your version 
26  // of this file under the terms of either the CDDL or the LGPL.
27  // 
28  // This library is distributed in the hope that it will be useful,
29  // but WITHOUT ANY WARRANTY; without even the implied warranty of
30  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
31  // ============================================================================
32  
33  package net.sf.jga.fn.comparison;
34  
35  import java.util.Comparator  ;
36  import net.sf.jga.fn.BinaryFunctor;
37  import net.sf.jga.fn.UnaryFunctor;
38  
39  /**
40   * Static factory methods for the functors in the Comparison package.
41   * <p>
42   * Copyright &copy; 2006  David A. Hall
43   * @author <a HREF="mailto:davidahall@users.sf.net">David A. Hall</a>
44   */
45  
46  public final class ComparisonFunctors {
47      /**
48       */
49      static public <T> UnaryFunctor<T,Boolean  > between(T lo, T hi, Comparator  <? super T> comp) {
50          return new Between<T>(lo, hi, comp);
51      }
52  
53      /**
54       */
55      static public <T extends Comparable  /*@*/<? super T>/*@*/> UnaryFunctor<T,Boolean  >
56      between(T lo, T hi)
57      {
58          return new Between.Comparable<T>(lo, hi);
59      }
60  
61      /**
62       */
63      static public <T> UnaryFunctor<T,Boolean  >
64      between(UnaryFunctor<T,Boolean  > lo, UnaryFunctor<T,Boolean  > hi)
65      {
66          return new Between<T>(lo, hi);
67      }
68  
69  
70      /**
71       */
72      static public <T> BinaryFunctor<T,T,Integer  > comparatorFn(Comparator  <T> comp) {
73          return new ComparatorFn<T>(comp);
74      }
75  
76      /**
77       */
78      static public <T> BinaryFunctor<T,T,Boolean  > equalEqual() {
79          return new EqualEqual<T>();
80      }
81  
82      /**
83       */
84      static public <T> UnaryFunctor<T,Boolean  > equalEqual(T value) {
85          return ComparisonFunctors.<T>equalEqual().bind2nd(value);
86      }
87  
88      /**
89       */
90      static public <T> BinaryFunctor<T,T,Boolean  > equalTo(Class  <T> hint) {
91          return new EqualTo<T>();
92      }
93  
94      /**
95       */
96      static public <T> BinaryFunctor<T,T,Boolean  > equalTo(Comparator  <? super T> comp) {
97          return new EqualTo<T>(comp);
98      }
99      
100     /**
101      */
102     static public <T> UnaryFunctor<T,Boolean  > equalTo(T value) {
103         return new EqualTo<T>().bind2nd(value);
104     }
105 
106     /**
107      */
108     static public <T> UnaryFunctor<T,Boolean  > equalTo(Comparator  <? super T> comp, T value) {
109         return new EqualTo<T>(comp).bind2nd(value);
110     }
111     
112     /**
113      */
114     static public <T> UnaryFunctor<T,Boolean  > equalTo(Equality<T> eq, T value) {
115         return eq.bind2nd(value);
116     }
117     
118     /**
119      */
120     static public <T> BinaryFunctor<T,T,Boolean  > greater(Comparator  <? super T> comp) {
121         return new Greater<T>(comp);
122     }
123 
124     /**
125      */
126     static public <T> UnaryFunctor<T,Boolean  > greater(Comparator  <? super T> comp, T value) {
127         return ComparisonFunctors.<T>greater(comp).bind2nd(value);
128     }
129 
130     /**
131      */
132     static public <T extends Comparable  /*@*/<? super T>/*@*/>
133     BinaryFunctor<T,T,Boolean  > greater(Class  <T> hint)
134     {
135         return new Greater.Comparable<T>();
136     }
137 
138     /**
139      */
140     static public <T extends Comparable  /*@*/<? super T>/*@*/> UnaryFunctor<T,Boolean  >
141     greater(T value)
142     {
143         return new Greater.Comparable<T>().bind2nd(value);
144     }
145 
146     /**
147      */
148     static public <T> BinaryFunctor<T,T,Boolean  > greaterEqual(Comparator  <? super T> comp) {
149         return new GreaterEqual<T>(comp);
150     }
151 
152     /**
153      */
154     static public <T> UnaryFunctor<T,Boolean  > greaterEqual(Comparator  <? super T> comp, T value) {
155         return ComparisonFunctors.<T>greaterEqual(comp).bind2nd(value);
156     }
157 
158     /**
159      */
160     static public <T extends Comparable  /*@*/<? super T>/*@*/> BinaryFunctor<T,T,Boolean  >
161     greaterEqual(Class  <T> hint)
162     {
163         return new GreaterEqual.Comparable<T>();
164     }
165 
166     /**
167      */
168     static public <T extends Comparable  /*@*/<? super T>/*@*/> UnaryFunctor<T,Boolean  >
169     greaterEqual(T value)
170     {
171         return new GreaterEqual.Comparable<T>().bind2nd(value);
172     }
173 
174     /**
175      */      
176     static public <T> UnaryFunctor<T,Boolean  > isNull() {
177         return new EqualTo<T>().bind2nd(null);
178     }
179 
180     /**
181      */
182     static public <T> UnaryFunctor<T,Boolean  > notNull() {
183         return new NotEqualTo<T>().bind2nd(null);
184     }
185 
186     /**
187      */
188     static public <T> BinaryFunctor<T,T,Boolean  > less(Comparator  <? super T> comp) {
189         return new Less<T>(comp);
190     }
191 
192     /**
193      */
194     static public <T> UnaryFunctor<T,Boolean  > less(Comparator  <? super T> comp, T value) {
195         return ComparisonFunctors.<T>less(comp).bind2nd(value);
196     }
197 
198     /**
199      */
200     static public <T extends Comparable  /*@*/<? super T>/*@*/> BinaryFunctor<T,T,Boolean  >
201     less(Class  <T> hint)
202     {
203         return new Less.Comparable<T>();
204     }
205 
206     /**
207      */
208     static public <T extends Comparable  /*@*/<? super T>/*@*/> UnaryFunctor<T,Boolean  >
209     less(T value)
210     {
211         return new Less.Comparable<T>().bind2nd(value);
212     }
213 
214     /**
215      */
216     static public <T> BinaryFunctor<T,T,Boolean  > lessEqual(Comparator  <? super T> comp) {
217         return new LessEqual<T>(comp);
218     }
219 
220     /**
221      */
222     static public <T> UnaryFunctor<T,Boolean  > lessEqual(Comparator  <? super T> comp, T value) {
223         return ComparisonFunctors.<T>lessEqual(comp).bind2nd(value);
224     }
225 
226     /**
227      */
228     static public <T extends Comparable  /*@*/<? super T>/*@*/> BinaryFunctor<T,T,Boolean  >
229     lessEqual(Class  <T> hint)
230     {
231         return new LessEqual.Comparable<T>();
232     }
233 
234     /**
235      */
236     static public <T extends Comparable  /*@*/<? super T>/*@*/> UnaryFunctor<T,Boolean  >
237     lessEqual(T value)
238     {
239         return new LessEqual.Comparable<T>().bind2nd(value);
240     }
241 
242     /**
243      */
244     static public <T> BinaryFunctor<T,T,T> max(Comparator  <? super T> comp) {
245         return new Max<T>(comp);
246     }
247     
248     /**
249      */
250     static public <T extends Comparable  /*@*/<? super T>/*@*/> BinaryFunctor<T,T,T>
251     max(Class  <T> hint)
252     {
253         return new Max.Comparable<T>();
254     }
255 
256     /**
257      */
258     static public <T> BinaryFunctor<T,T,T> min(Comparator  <? super T> comp) {
259         return new Min<T>(comp);
260     }
261     
262     /**
263      */
264     static public <T extends Comparable  /*@*/<? super T>/*@*/> BinaryFunctor<T,T,T>
265     min(Class  <T> hint)
266     {
267         return new Min.Comparable<T>();
268     }
269 
270     /**
271      */
272     static public <T> BinaryFunctor<T,T,Boolean  > notEqualEqual() {
273         return new NotEqualEqual<T>();
274     }
275 
276     /**
277      */
278     static public <T> UnaryFunctor<T,Boolean  > notEqualEqual(T value) {
279         return new NotEqualEqual<T>().bind2nd(value);
280     }
281 
282     /**
283      */
284     static public <T> BinaryFunctor<T,T,Boolean  > notEqualTo(Class  <T> hint) {
285         return new NotEqualTo<T>();
286     }
287 
288     /**
289      */
290     static public <T> BinaryFunctor<T,T,Boolean  > notEqualTo(Comparator  <? super T> comp) {
291         return new NotEqualTo<T>(comp);
292     }
293     
294     /**
295      */
296     static public <T> UnaryFunctor<T,Boolean  > notEqualTo(T value) {
297         return new NotEqualTo<T>().bind2nd(value);
298     }
299 
300     /**
301      */
302     static public <T> UnaryFunctor<T,Boolean  > notEqualTo(Comparator  <? super T> comp, T value) {
303         return new NotEqualTo<T>(comp).bind2nd(value);
304     }
305 }
306 
307
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags