001: // ============================================================================
002: // $Id: ArithmeticFunctors.java,v 1.2 2006/12/16 16:48:58 davidahall Exp $
003: // Copyright (c) 2006 David A. Hall
004: // ============================================================================
005: // The contents of this file are subject to the Common Development and
006: // Distribution License (CDDL), Version 1.0 (the License); you may not use this
007: // file except in compliance with the License. You should have received a copy
008: // of the the License along with this file: if not, a copy of the License is
009: // available from Sun Microsystems, Inc.
010: //
011: // http://www.sun.com/cddl/cddl.html
012: //
013: // From time to time, the license steward (initially Sun Microsystems, Inc.) may
014: // publish revised and/or new versions of the License. You may not use,
015: // distribute, or otherwise make this file available under subsequent versions
016: // of the License.
017: //
018: // Alternatively, the contents of this file may be used under the terms of the
019: // GNU Lesser General Public License Version 2.1 or later (the "LGPL"), in which
020: // case the provisions of the LGPL are applicable instead of those above. If you
021: // wish to allow use of your version of this file only under the terms of the
022: // LGPL, and not to allow others to use your version of this file under the
023: // terms of the CDDL, indicate your decision by deleting the provisions above
024: // and replace them with the notice and other provisions required by the LGPL.
025: // If you do not delete the provisions above, a recipient may use your version
026: // of this file under the terms of either the CDDL or the LGPL.
027: //
028: // This library is distributed in the hope that it will be useful,
029: // but WITHOUT ANY WARRANTY; without even the implied warranty of
030: // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
031: // ============================================================================
032:
033: package net.sf.jga.fn.arithmetic;
034:
035: import java.util.Iterator;
036: import net.sf.jga.fn.BinaryFunctor;
037: import net.sf.jga.fn.UnaryFunctor;
038:
039: /**
040: * Static factory methods for the functors in the Comparison package.
041: * <p>
042: * Copyright © 2006 David A. Hall
043: */
044:
045: // This class suppresses unchecked cast warnings in numerous methods that take a generic
046: // value of type T, call getClass(), then cast the class to a Class<T>. I believe that
047: // the warning is technically correct, but the way these methods are written, you'd have
048: // to be pretty abusive to trigger the error condition.
049: public final class ArithmeticFunctors {
050: /**
051: */
052: static public <T extends Number> UnaryFunctor<Iterator<T>, T> average(
053: Class<T> t) {
054: return new Average<T>(t);
055: }
056:
057: // /**
058: // */
059: // static public <T extends Number> BinaryFunctor<T,T,T> and(Class<T> t) {
060: // return new BitwiseAnd<T>(t);
061: // }
062:
063: // /**
064: // */
065: // @SuppressWarnings("unchecked")
066: // static public <T extends Number> UnaryFunctor<T,T> and(T value) {
067: // return new BitwiseAnd<T>((Class<T>) value.getClass()).bind2nd(value);
068: // }
069:
070: /**
071: */
072: static public <T extends Number> BinaryFunctor<T, T, T> bitwiseAnd(
073: Class<T> t) {
074: return new BitwiseAnd<T>(t);
075: }
076:
077: /**
078: */
079: @SuppressWarnings("unchecked")
080: static public <T extends Number> UnaryFunctor<T, T> bitwiseAnd(
081: T value) {
082: return new BitwiseAnd<T>((Class<T>) value.getClass())
083: .bind2nd(value);
084: }
085:
086: /**
087: */
088: static public <T extends Number> UnaryFunctor<T, T> bitwiseNot(
089: Class<T> t) {
090: return new BitwiseNot<T>(t);
091: }
092:
093: /**
094: */
095: static public <T extends Number> BinaryFunctor<T, T, T> bitwiseOr(
096: Class<T> t) {
097: return new BitwiseOr<T>(t);
098: }
099:
100: /**
101: */
102: @SuppressWarnings("unchecked")
103: static public <T extends Number> UnaryFunctor<T, T> bitwiseOr(
104: T value) {
105: return new BitwiseOr<T>((Class<T>) value.getClass())
106: .bind2nd(value);
107: }
108:
109: /**
110: */
111: static public <T extends Number> BinaryFunctor<T, T, T> bitwiseXor(
112: Class<T> t) {
113: return new BitwiseXor<T>(t);
114: }
115:
116: /**
117: */
118: @SuppressWarnings("unchecked")
119: static public <T extends Number> UnaryFunctor<T, T> bitwiseXor(
120: T value) {
121: return new BitwiseXor<T>((Class<T>) value.getClass())
122: .bind2nd(value);
123: }
124:
125: /**
126: */
127: static public <T extends Number> BinaryFunctor<T, T, T> divides(
128: Class<T> t) {
129: return new Divides<T>(t);
130: }
131:
132: /**
133: */
134: @SuppressWarnings("unchecked")
135: static public <T extends Number> UnaryFunctor<T, T> divides(T value) {
136: // Unchecked warning
137: return new Divides<T>((Class<T>) value.getClass())
138: .bind2nd(value);
139: }
140:
141: /**
142: */
143: static public <T extends Number> BinaryFunctor<T, T, T> minus(
144: Class<T> t) {
145: return new Minus<T>(t);
146: }
147:
148: /**
149: */
150: @SuppressWarnings("unchecked")
151: static public <T extends Number> UnaryFunctor<T, T> minus(T value) {
152: return new Minus<T>((Class<T>) value.getClass()).bind2nd(value);
153: }
154:
155: /**
156: */
157: static public <T extends Number> BinaryFunctor<T, T, T> modulus(
158: Class<T> t) {
159: return new Modulus<T>(t);
160: }
161:
162: /**
163: */
164: @SuppressWarnings("unchecked")
165: static public <T extends Number> UnaryFunctor<T, T> modulus(T value) {
166: return new Modulus<T>((Class<T>) value.getClass())
167: .bind2nd(value);
168: }
169:
170: /**
171: */
172: static public <T extends Number> BinaryFunctor<T, T, T> multiplies(
173: Class<T> t) {
174: return new Multiplies<T>(t);
175: }
176:
177: /**
178: */
179: @SuppressWarnings("unchecked")
180: static public <T extends Number> UnaryFunctor<T, T> multiplies(
181: T value) {
182: return new Multiplies<T>((Class<T>) value.getClass())
183: .bind2nd(value);
184: }
185:
186: /**
187: */
188: static public <T extends Number> UnaryFunctor<T, T> negate(
189: Class<T> t) {
190: return new Negate<T>(t);
191: }
192:
193: // /**
194: // /**
195: // */
196: // static public <T extends Number> UnaryFunctor<T,T> not(Class<T> t) {
197: // return new BitwiseNot<T>(t);
198: // }
199:
200: // */
201: // static public <T extends Number> BinaryFunctor<T,T,T> or(Class<T> t) {
202: // return new BitwiseOr<T>(t);
203: // }
204:
205: // /**
206: // */
207: // @SuppressWarnings("unchecked")
208: // static public <T extends Number> UnaryFunctor<T,T> or(T value) {
209: // return new BitwiseOr<T>((Class<T>) value.getClass()).bind2nd(value);
210: // }
211:
212: /**
213: */
214: static public <T extends Number> BinaryFunctor<T, T, T> plus(
215: Class<T> t) {
216: return new Plus<T>(t);
217: }
218:
219: /**
220: */
221: @SuppressWarnings("unchecked")
222: static public <T extends Number> UnaryFunctor<T, T> plus(T value) {
223: return new Plus<T>((Class<T>) value.getClass()).bind2nd(value);
224: }
225:
226: /**
227: */
228: static public <T extends Number> BinaryFunctor<T, Integer, T> shiftLeft(
229: Class<T> t) {
230: return new ShiftLeft<T>(t);
231: }
232:
233: /**
234: */
235: static public <T extends Number> BinaryFunctor<T, Integer, T> shiftRight(
236: Class<T> t) {
237: return new ShiftRight<T>(t);
238: }
239:
240: /**
241: */
242: static public <T extends Number> BinaryFunctor<T, Integer, T> unsignedShiftRight(
243: Class<T> t) {
244: return new UnsignedShiftRight<T>(t);
245: }
246:
247: /**
248: */
249: static public <T extends Number, R extends Number> UnaryFunctor<T, R> valueOf(
250: Class<R> r) {
251: return new ValueOf<T, R>(r);
252: }
253:
254: // /**
255: // */
256: // static public <T extends Number> BinaryFunctor<T,T,T> xor(Class<T> t) {
257: // return new BitwiseXor<T>(t);
258: // }
259:
260: // /**
261: // */
262: // @SuppressWarnings("unchecked")
263: // static public <T extends Number> UnaryFunctor<T,T> xor(T value) {
264: // return new BitwiseXor<T>((Class<T>) value.getClass()).bind2nd(value);
265: // }
266: }
|