Coverage Report

Coverage Report - org.kuali.rice.kns.util.KualiInteger

Classes in this File

Line Coverage

Branch Coverage

Complexity

KualiInteger

0/82

0/50

1.939

 /*
  * Copyright 2006-2007 The Kuali Foundation
  * 
  * Licensed under the Educational Community 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.opensource.org/licenses/ecl2.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.kns.util;
 
 import java.math.BigDecimal;
 import java.math.BigInteger;
 import java.math.MathContext;
 import java.math.RoundingMode;
 
 public class KualiInteger extends Number implements Comparable {
     public static final int ROUND_BEHAVIOR = KualiDecimal.ROUND_BEHAVIOR;
     public static final int SCALE = 0;
 
     public static KualiInteger ZERO = new KualiInteger(0);
 
     private final BigInteger value;
 
     /**
      * Constructor - only accepts a string representation of the value.
      * 
      * This is done to prevent unexpected inaccuracy by conversion to and from floating-point values.
      * 
      * @param value String containing numeric value
      * @throws IllegalArgumentException if the given String is null
      */
     public KualiInteger(String value) {
         if (value == null) {
             throw new IllegalArgumentException("invalid (null) String in KualiInteger constructor");
         }
 
         this.value = new BigInteger(value);
     }
 
     /**
      * Initializes this instance to the given integer value with integer arithmetic.
      */
     public KualiInteger(long value) {
         this.value = BigInteger.valueOf(value);
     }
 
     /**
      * Simple constructor, copies in the given BigInteger as the value for the instance.
      * 
      * @param value BigInteger to be used as basis for value
      * @throws IllegalArgumentException if the given BigDecimal is null
      */
     public KualiInteger(BigInteger value) {
         if (value == null) {
             throw new IllegalArgumentException("invalid (null) BigDecimal in KualiDecimal constructor");
         }
 
         this.value = value;
     }
 
     /**
      * Simple constructor, copies in the given BigInteger as the value for the instance.
      * 
      * @param value BigInteger to be used as basis for value
      * @throws IllegalArgumentException if the given BigDecimal is null
      */
     public KualiInteger(BigDecimal value) {
         if (value == null) {
             throw new IllegalArgumentException("invalid (null) BigDecimal in KualiDecimal constructor");
         }
 
         this.value = value.setScale(SCALE, ROUND_BEHAVIOR).toBigInteger();
     }
 
     /**
      * Simple constructor, rounds the given KualiDecimal according to the RoundingMode
      * 
      * @param value KualiDecmial to be used as basis for value
      * @param roundingMode RoundingMode for converting to Integer
      * @throws IllegalArgumentException if the given KualiDecmial or RoundingMode is null
      */
     public KualiInteger(KualiDecimal value, RoundingMode roundingMode) {
         if (value == null) {
             throw new IllegalArgumentException("invalid (null) KualiDecimal in KualiInteger constructor");
         }
         if (roundingMode == null) {
             throw new IllegalArgumentException("invalid (null) RoundingMode in KualiInteger constructor");
         }
 
         this.value = value.bigDecimalValue().round(new MathContext(0, roundingMode)).toBigInteger();
     }
 
     /**
      * Wraps BigDecimal's add method to accept and return KualiDecimal instances instead of BigDecimals, so that users of the class
      * don't have to typecast the return value.
      * 
      * @param addend
      * @return result of adding the given addend to this value
      * @throws IllegalArgumentException if the given addend is null
      */
     public KualiInteger add(KualiInteger addend) {
         if (addend == null) {
             throw new IllegalArgumentException("invalid (null) addend");
         }
 
         BigInteger sum = this.value.add(addend.value);
         return new KualiInteger(sum);
     }
 
     /**
      * Wraps BigDecimal's subtract method to accept and return KualiDecimal instances instead of BigDecimals, so that users of the
      * class don't have to typecast the return value.
      * 
      * @param subtrahend
      * @return result of the subtracting the given subtrahend from this value
      * @throws IllegalArgumentException if the given subtrahend is null
      */
     public KualiInteger subtract(KualiInteger subtrahend) {
         if (subtrahend == null) {
             throw new IllegalArgumentException("invalid (null) subtrahend");
         }
 
         BigInteger difference = this.value.subtract(subtrahend.value);
         return new KualiInteger(difference);
     }
 
     /**
      * Wraps BigDecimal's multiply method to accept and return KualiInteger instances instead of BigDecimals, so that users of the
      * class don't have to typecast the return value.
      * 
      * @param multiplicand
      * @return result of multiplying this value by the given multiplier
      * @throws IllegalArgumentException if the given multiplier is null
      */
     public KualiInteger multiply(KualiInteger multiplier) {
         if (multiplier == null) {
             throw new IllegalArgumentException("invalid (null) multiplier");
         }
 
         BigInteger product = this.value.multiply(multiplier.value);
         return new KualiInteger(product);
     }
 
     public KualiInteger multiply(BigDecimal multiplier) {
         if (multiplier == null) {
             throw new IllegalArgumentException("invalid (null) multiplier");
         }
 
         BigDecimal product = multiplier.multiply(new BigDecimal(this.value));
         return new KualiInteger(product);
     }
 
     public KualiInteger multiply(KualiDecimal multiplier) {
         return multiply(multiplier.bigDecimalValue());
     }
 
 
     public BigDecimal divide(BigDecimal dividend) {
         if (dividend == null) {
             throw new IllegalArgumentException("invalid (null) dividend");
         }
 
         return this.bigDecimalValue().divide(dividend, 8, ROUND_BEHAVIOR);
     }
 
     public BigDecimal divide(KualiInteger dividend) {
         if (dividend == null) {
             throw new IllegalArgumentException("invalid (null) dividend");
         }
 
         return divide(dividend.bigDecimalValue());
     }
 
     // Number methods
     /**
      * @see java.lang.Number#doubleValue()
      */
     public double doubleValue() {
         return this.value.doubleValue();
     }
 
     /**
      * @see java.lang.Number#floatValue()
      */
     public float floatValue() {
         return this.value.floatValue();
     }
 
     /**
      * @see java.lang.Number#intValue()
      */
     public int intValue() {
         return this.value.intValue();
     }
 
     /**
      * @see java.lang.Number#longValue()
      */
     public long longValue() {
         return this.value.longValue();
     }
 
     /**
      * @return the value of this instance as a BigDecimal.
      */
     public BigInteger bigIntegerValue() {
         return this.value;
     }
 
     /**
      * @return the value of this instance as a BigDecimal.
      */
     public BigDecimal bigDecimalValue() {
         return new BigDecimal(this.value);
     }
 
     /**
      * @return the value of this instance as a BigDecimal.
      */
     public KualiDecimal kualiDecimalValue() {
         return new KualiDecimal(this.bigDecimalValue());
     }
 
 
     /**
      * @param operand
      * @return true if this KualiDecimal is less than the given KualiDecimal
      */
     public boolean isLessThan(KualiInteger operand) {
         if (operand == null) {
             throw new IllegalArgumentException("invalid (null) operand");
         }
 
         return (this.compareTo(operand) == -1);
     }
 
     /**
      * @param operand
      * @return true if this KualiDecimal is greater than the given KualiDecimal
      */
     public boolean isGreaterThan(KualiInteger operand) {
         if (operand == null) {
             throw new IllegalArgumentException("invalid (null) operand");
         }
 
         return (this.compareTo(operand) == 1);
     }
 
     /**
      * @param operand
      * @return true if this KualiDecimal is less than or equal to the given KualiDecimal
      */
     public boolean isLessEqual(KualiInteger operand) {
         if (operand == null) {
             throw new IllegalArgumentException("invalid (null) operand");
         }
 
         return !isGreaterThan(operand);
     }
 
     /**
      * @param operand
      * @return true if this KualiDecimal is greater than or equal to the given KualiDecimal
      */
     public boolean isGreaterEqual(KualiInteger operand) {
         if (operand == null) {
             throw new IllegalArgumentException("invalid (null) operand");
         }
 
         return !isLessThan(operand);
     }
 
     /**
      * @return true if this KualiDecimal is less than zero
      */
     public boolean isNegative() {
         return (this.compareTo(ZERO) == -1);
     }
 
     /**
      * @return true if this KualiDecimal is greater than zero
      */
     public boolean isPositive() {
         return (this.compareTo(ZERO) == 1);
     }
 
 
     /**
      * @return true if this KualiDecimal is equal to zero
      */
     public boolean isZero() {
         return (this.compareTo(ZERO) == 0);
     }
 
 
     /**
      * @return true if this KualiDecimal is not equal to zero
      */
     public boolean isNonZero() {
         return !this.isZero();
     }
 
     /**
      * @return a KualiInteger with the same scale and a negated value (iff the value is non-zero)
      */
     public KualiInteger negated() {
         return multiply(new KualiInteger("-1"));
     }
 
 
     // Comparable methods
     /**
      * Compares this KualiInteger with the specified Object. If the Object is a KualiInteger, this method behaves like
      * java.lang.Comparable#compareTo(java.lang.Object).
      * 
      * Otherwise, it throws a <tt>ClassCastException</tt> (as KualiIntegers are comparable only to other KualiIntegers).
      * 
      * @see java.lang.Comparable#compareTo(java.lang.Object)
      */
     public int compareTo(Object o) {
         return compareTo((KualiInteger) o);
     }
 
     /**
      * Returns the result of comparing the values of this KualiInteger and the given KualiInteger.
      * 
      * @see java.lang.Comparable#compareTo(java.lang.Object)
      */
     public int compareTo(KualiInteger k) {
         return this.value.compareTo(k.value);
     }
 
 
     // Object methods
     /**
      * @see java.lang.Object#equals(java.lang.Object)
      */
     public boolean equals(Object obj) {
         boolean equals = false;
 
         if (obj instanceof KualiInteger) {
             KualiInteger k = (KualiInteger) obj;
 
             // using KualiInteger.compareTo instead of BigDecimal.equals since BigDecimal.equals only returns true if the
             // scale and precision are equal, rather than comparing the actual (scaled) values
             equals = (this.compareTo(k) == 0);
         }
 
         return equals;
     }
 
     /**
      * 
      * @see java.lang.Object#hashCode()
      */
     public int hashCode() {
         return this.value.hashCode();
     }
 
     /**
      * @see java.lang.Object#toString()
      */
     public String toString() {
         return this.value.toString();
     }
 
 }

1		/*
2		* Copyright 2006-2007 The Kuali Foundation
3		*
4		* Licensed under the Educational Community License, Version 2.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/ecl2.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.kns.util;
17
18		import java.math.BigDecimal;
19		import java.math.BigInteger;
20		import java.math.MathContext;
21		import java.math.RoundingMode;
22
23		public class KualiInteger extends Number implements Comparable {
24		public static final int ROUND_BEHAVIOR = KualiDecimal.ROUND_BEHAVIOR;
25		public static final int SCALE = 0;
26
27	0	public static KualiInteger ZERO = new KualiInteger(0);
28
29		private final BigInteger value;
30
31		/**
32		* Constructor - only accepts a string representation of the value.
33		*
34		* This is done to prevent unexpected inaccuracy by conversion to and from floating-point values.
35		*
36		* @param value String containing numeric value
37		* @throws IllegalArgumentException if the given String is null
38		*/
39	0	public KualiInteger(String value) {
40	0	if (value == null) {
41	0	throw new IllegalArgumentException("invalid (null) String in KualiInteger constructor");
42		}
43
44	0	this.value = new BigInteger(value);
45	0	}
46
47		/**
48		* Initializes this instance to the given integer value with integer arithmetic.
49		*/
50	0	public KualiInteger(long value) {
51	0	this.value = BigInteger.valueOf(value);
52	0	}
53
54		/**
55		* Simple constructor, copies in the given BigInteger as the value for the instance.
56		*
57		* @param value BigInteger to be used as basis for value
58		* @throws IllegalArgumentException if the given BigDecimal is null
59		*/
60	0	public KualiInteger(BigInteger value) {
61	0	if (value == null) {
62	0	throw new IllegalArgumentException("invalid (null) BigDecimal in KualiDecimal constructor");
63		}
64
65	0	this.value = value;
66	0	}
67
68		/**
69		* Simple constructor, copies in the given BigInteger as the value for the instance.
70		*
71		* @param value BigInteger to be used as basis for value
72		* @throws IllegalArgumentException if the given BigDecimal is null
73		*/
74	0	public KualiInteger(BigDecimal value) {
75	0	if (value == null) {
76	0	throw new IllegalArgumentException("invalid (null) BigDecimal in KualiDecimal constructor");
77		}
78
79	0	this.value = value.setScale(SCALE, ROUND_BEHAVIOR).toBigInteger();
80	0	}
81
82		/**
83		* Simple constructor, rounds the given KualiDecimal according to the RoundingMode
84		*
85		* @param value KualiDecmial to be used as basis for value
86		* @param roundingMode RoundingMode for converting to Integer
87		* @throws IllegalArgumentException if the given KualiDecmial or RoundingMode is null
88		*/
89	0	public KualiInteger(KualiDecimal value, RoundingMode roundingMode) {
90	0	if (value == null) {
91	0	throw new IllegalArgumentException("invalid (null) KualiDecimal in KualiInteger constructor");
92		}
93	0	if (roundingMode == null) {
94	0	throw new IllegalArgumentException("invalid (null) RoundingMode in KualiInteger constructor");
95		}
96
97	0	this.value = value.bigDecimalValue().round(new MathContext(0, roundingMode)).toBigInteger();
98	0	}
99
100		/**
101		* Wraps BigDecimal's add method to accept and return KualiDecimal instances instead of BigDecimals, so that users of the class
102		* don't have to typecast the return value.
103		*
104		* @param addend
105		* @return result of adding the given addend to this value
106		* @throws IllegalArgumentException if the given addend is null
107		*/
108		public KualiInteger add(KualiInteger addend) {
109	0	if (addend == null) {
110	0	throw new IllegalArgumentException("invalid (null) addend");
111		}
112
113	0	BigInteger sum = this.value.add(addend.value);
114	0	return new KualiInteger(sum);
115		}
116
117		/**
118		* Wraps BigDecimal's subtract method to accept and return KualiDecimal instances instead of BigDecimals, so that users of the
119		* class don't have to typecast the return value.
120		*
121		* @param subtrahend
122		* @return result of the subtracting the given subtrahend from this value
123		* @throws IllegalArgumentException if the given subtrahend is null
124		*/
125		public KualiInteger subtract(KualiInteger subtrahend) {
126	0	if (subtrahend == null) {
127	0	throw new IllegalArgumentException("invalid (null) subtrahend");
128		}
129
130	0	BigInteger difference = this.value.subtract(subtrahend.value);
131	0	return new KualiInteger(difference);
132		}
133
134		/**
135		* Wraps BigDecimal's multiply method to accept and return KualiInteger instances instead of BigDecimals, so that users of the
136		* class don't have to typecast the return value.
137		*
138		* @param multiplicand
139		* @return result of multiplying this value by the given multiplier
140		* @throws IllegalArgumentException if the given multiplier is null
141		*/
142		public KualiInteger multiply(KualiInteger multiplier) {
143	0	if (multiplier == null) {
144	0	throw new IllegalArgumentException("invalid (null) multiplier");
145		}
146
147	0	BigInteger product = this.value.multiply(multiplier.value);
148	0	return new KualiInteger(product);
149		}
150
151		public KualiInteger multiply(BigDecimal multiplier) {
152	0	if (multiplier == null) {
153	0	throw new IllegalArgumentException("invalid (null) multiplier");
154		}
155
156	0	BigDecimal product = multiplier.multiply(new BigDecimal(this.value));
157	0	return new KualiInteger(product);
158		}
159
160		public KualiInteger multiply(KualiDecimal multiplier) {
161	0	return multiply(multiplier.bigDecimalValue());
162		}
163
164
165		public BigDecimal divide(BigDecimal dividend) {
166	0	if (dividend == null) {
167	0	throw new IllegalArgumentException("invalid (null) dividend");
168		}
169
170	0	return this.bigDecimalValue().divide(dividend, 8, ROUND_BEHAVIOR);
171		}
172
173		public BigDecimal divide(KualiInteger dividend) {
174	0	if (dividend == null) {
175	0	throw new IllegalArgumentException("invalid (null) dividend");
176		}
177
178	0	return divide(dividend.bigDecimalValue());
179		}
180
181		// Number methods
182		/**
183		* @see java.lang.Number#doubleValue()
184		*/
185		public double doubleValue() {
186	0	return this.value.doubleValue();
187		}
188
189		/**
190		* @see java.lang.Number#floatValue()
191		*/
192		public float floatValue() {
193	0	return this.value.floatValue();
194		}
195
196		/**
197		* @see java.lang.Number#intValue()
198		*/
199		public int intValue() {
200	0	return this.value.intValue();
201		}
202
203		/**
204		* @see java.lang.Number#longValue()
205		*/
206		public long longValue() {
207	0	return this.value.longValue();
208		}
209
210		/**
211		* @return the value of this instance as a BigDecimal.
212		*/
213		public BigInteger bigIntegerValue() {
214	0	return this.value;
215		}
216
217		/**
218		* @return the value of this instance as a BigDecimal.
219		*/
220		public BigDecimal bigDecimalValue() {
221	0	return new BigDecimal(this.value);
222		}
223
224		/**
225		* @return the value of this instance as a BigDecimal.
226		*/
227		public KualiDecimal kualiDecimalValue() {
228	0	return new KualiDecimal(this.bigDecimalValue());
229		}
230
231
232		/**
233		* @param operand
234		* @return true if this KualiDecimal is less than the given KualiDecimal
235		*/
236		public boolean isLessThan(KualiInteger operand) {
237	0	if (operand == null) {
238	0	throw new IllegalArgumentException("invalid (null) operand");
239		}
240
241	0	return (this.compareTo(operand) == -1);
242		}
243
244		/**
245		* @param operand
246		* @return true if this KualiDecimal is greater than the given KualiDecimal
247		*/
248		public boolean isGreaterThan(KualiInteger operand) {
249	0	if (operand == null) {
250	0	throw new IllegalArgumentException("invalid (null) operand");
251		}
252
253	0	return (this.compareTo(operand) == 1);
254		}
255
256		/**
257		* @param operand
258		* @return true if this KualiDecimal is less than or equal to the given KualiDecimal
259		*/
260		public boolean isLessEqual(KualiInteger operand) {
261	0	if (operand == null) {
262	0	throw new IllegalArgumentException("invalid (null) operand");
263		}
264
265	0	return !isGreaterThan(operand);
266		}
267
268		/**
269		* @param operand
270		* @return true if this KualiDecimal is greater than or equal to the given KualiDecimal
271		*/
272		public boolean isGreaterEqual(KualiInteger operand) {
273	0	if (operand == null) {
274	0	throw new IllegalArgumentException("invalid (null) operand");
275		}
276
277	0	return !isLessThan(operand);
278		}
279
280		/**
281		* @return true if this KualiDecimal is less than zero
282		*/
283		public boolean isNegative() {
284	0	return (this.compareTo(ZERO) == -1);
285		}
286
287		/**
288		* @return true if this KualiDecimal is greater than zero
289		*/
290		public boolean isPositive() {
291	0	return (this.compareTo(ZERO) == 1);
292		}
293
294
295		/**
296		* @return true if this KualiDecimal is equal to zero
297		*/
298		public boolean isZero() {
299	0	return (this.compareTo(ZERO) == 0);
300		}
301
302
303		/**
304		* @return true if this KualiDecimal is not equal to zero
305		*/
306		public boolean isNonZero() {
307	0	return !this.isZero();
308		}
309
310		/**
311		* @return a KualiInteger with the same scale and a negated value (iff the value is non-zero)
312		*/
313		public KualiInteger negated() {
314	0	return multiply(new KualiInteger("-1"));
315		}
316
317
318		// Comparable methods
319		/**
320		* Compares this KualiInteger with the specified Object. If the Object is a KualiInteger, this method behaves like
321		* java.lang.Comparable#compareTo(java.lang.Object).
322		*
323		* Otherwise, it throws a <tt>ClassCastException</tt> (as KualiIntegers are comparable only to other KualiIntegers).
324		*
325		* @see java.lang.Comparable#compareTo(java.lang.Object)
326		*/
327		public int compareTo(Object o) {
328	0	return compareTo((KualiInteger) o);
329		}
330
331		/**
332		* Returns the result of comparing the values of this KualiInteger and the given KualiInteger.
333		*
334		* @see java.lang.Comparable#compareTo(java.lang.Object)
335		*/
336		public int compareTo(KualiInteger k) {
337	0	return this.value.compareTo(k.value);
338		}
339
340
341		// Object methods
342		/**
343		* @see java.lang.Object#equals(java.lang.Object)
344		*/
345		public boolean equals(Object obj) {
346	0	boolean equals = false;
347
348	0	if (obj instanceof KualiInteger) {
349	0	KualiInteger k = (KualiInteger) obj;
350
351		// using KualiInteger.compareTo instead of BigDecimal.equals since BigDecimal.equals only returns true if the
352		// scale and precision are equal, rather than comparing the actual (scaled) values
353	0	equals = (this.compareTo(k) == 0);
354		}
355
356	0	return equals;
357		}
358
359		/**
360		*
361		* @see java.lang.Object#hashCode()
362		*/
363		public int hashCode() {
364	0	return this.value.hashCode();
365		}
366
367		/**
368		* @see java.lang.Object#toString()
369		*/
370		public String toString() {
371	0	return this.value.toString();
372		}
373
374		}