001: /*
002: * Licensed to the Apache Software Foundation (ASF) under one or more
003: * contributor license agreements. See the NOTICE file distributed with
004: * this work for additional information regarding copyright ownership.
005: * The ASF licenses this file to You under the Apache License, Version 2.0
006: * (the "License"); you may not use this file except in compliance with
007: * the License. You may obtain a copy of the License at
008: *
009: * http://www.apache.org/licenses/LICENSE-2.0
010: *
011: * Unless required by applicable law or agreed to in writing, software
012: * distributed under the License is distributed on an "AS IS" BASIS,
013: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014: * See the License for the specific language governing permissions and
015: * limitations under the License.
016: */
017: package org.apache.commons.lang.mutable;
018:
019: /**
020: * A mutable <code>int</code> wrapper.
021: *
022: * @see Integer
023: * @since 2.1
024: * @version $Id: MutableInt.java 437554 2006-08-28 06:21:41Z bayard $
025: */
026: public class MutableInt extends Number implements Comparable, Mutable {
027:
028: /**
029: * Required for serialization support.
030: *
031: * @see java.io.Serializable
032: */
033: private static final long serialVersionUID = 512176391864L;
034:
035: /** The mutable value. */
036: private int value;
037:
038: /**
039: * Constructs a new MutableInt with the default value of zero.
040: */
041: public MutableInt() {
042: super ();
043: }
044:
045: /**
046: * Constructs a new MutableInt with the specified value.
047: *
048: * @param value
049: * a value.
050: */
051: public MutableInt(int value) {
052: super ();
053: this .value = value;
054: }
055:
056: /**
057: * Constructs a new MutableInt with the specified value.
058: *
059: * @param value
060: * a value.
061: * @throws NullPointerException
062: * if the object is null
063: */
064: public MutableInt(Number value) {
065: super ();
066: this .value = value.intValue();
067: }
068:
069: //-----------------------------------------------------------------------
070: /**
071: * Gets the value as a Integer instance.
072: *
073: * @return the value as a Integer
074: */
075: public Object getValue() {
076: return new Integer(this .value);
077: }
078:
079: /**
080: * Sets the value.
081: *
082: * @param value
083: * the value to set
084: */
085: public void setValue(int value) {
086: this .value = value;
087: }
088:
089: /**
090: * Sets the value from any Number instance.
091: *
092: * @param value
093: * the value to set
094: * @throws NullPointerException
095: * if the object is null
096: * @throws ClassCastException
097: * if the type is not a {@link Number}
098: */
099: public void setValue(Object value) {
100: setValue(((Number) value).intValue());
101: }
102:
103: //-----------------------------------------------------------------------
104: /**
105: * Increments the value.
106: *
107: * @since Commons Lang 2.2
108: */
109: public void increment() {
110: value++;
111: }
112:
113: /**
114: * Decrements the value.
115: *
116: * @since Commons Lang 2.2
117: */
118: public void decrement() {
119: value--;
120: }
121:
122: //-----------------------------------------------------------------------
123: /**
124: * Adds a value.
125: *
126: * @param operand
127: * the value to add
128: *
129: * @since Commons Lang 2.2
130: */
131: public void add(int operand) {
132: this .value += operand;
133: }
134:
135: /**
136: * Adds a value.
137: *
138: * @param operand
139: * the value to add
140: * @throws NullPointerException
141: * if the object is null
142: *
143: * @since Commons Lang 2.2
144: */
145: public void add(Number operand) {
146: this .value += operand.intValue();
147: }
148:
149: /**
150: * Subtracts a value.
151: *
152: * @param operand
153: * the value to add
154: *
155: * @since Commons Lang 2.2
156: */
157: public void subtract(int operand) {
158: this .value -= operand;
159: }
160:
161: /**
162: * Subtracts a value.
163: *
164: * @param operand
165: * the value to add
166: * @throws NullPointerException
167: * if the object is null
168: *
169: * @since Commons Lang 2.2
170: */
171: public void subtract(Number operand) {
172: this .value -= operand.intValue();
173: }
174:
175: //-----------------------------------------------------------------------
176: // shortValue and bytValue rely on Number implementation
177: /**
178: * Returns the value of this MutableInt as a int.
179: *
180: * @return the numeric value represented by this object after conversion to type int.
181: */
182: public int intValue() {
183: return value;
184: }
185:
186: /**
187: * Returns the value of this MutableInt as a long.
188: *
189: * @return the numeric value represented by this object after conversion to type long.
190: */
191: public long longValue() {
192: return value;
193: }
194:
195: /**
196: * Returns the value of this MutableInt as a float.
197: *
198: * @return the numeric value represented by this object after conversion to type float.
199: */
200: public float floatValue() {
201: return value;
202: }
203:
204: /**
205: * Returns the value of this MutableInt as a double.
206: *
207: * @return the numeric value represented by this object after conversion to type double.
208: */
209: public double doubleValue() {
210: return value;
211: }
212:
213: //-----------------------------------------------------------------------
214: /**
215: * Gets this mutable as an instance of Integer.
216: *
217: * @return a Integer instance containing the value from this mutable
218: */
219: public Integer toInteger() {
220: return new Integer(intValue());
221: }
222:
223: //-----------------------------------------------------------------------
224: /**
225: * Compares this object to the specified object. The result is <code>true</code> if and only if the argument is
226: * not <code>null</code> and is an <code>MutableInt</code> object that contains the same <code>int</code> value
227: * as this object.
228: *
229: * @param obj
230: * the object to compare with.
231: * @return <code>true</code> if the objects are the same; <code>false</code> otherwise.
232: */
233: public boolean equals(Object obj) {
234: if (obj instanceof MutableInt) {
235: return value == ((MutableInt) obj).intValue();
236: }
237: return false;
238: }
239:
240: /**
241: * Returns a suitable hashcode for this mutable.
242: *
243: * @return a suitable hashcode
244: */
245: public int hashCode() {
246: return value;
247: }
248:
249: /**
250: * Compares this mutable to another in ascending order.
251: *
252: * @param obj
253: * the mutable to compare to
254: * @return negative if this is less, zero if equal, positive if greater
255: * @throws ClassCastException if the argument is not a MutableInt
256: */
257: public int compareTo(Object obj) {
258: MutableInt other = (MutableInt) obj;
259: int anotherVal = other.value;
260: return value < anotherVal ? -1 : (value == anotherVal ? 0 : 1);
261: }
262:
263: /**
264: * Returns the String value of this mutable.
265: *
266: * @return the mutable value as a string
267: */
268: public String toString() {
269: return String.valueOf(value);
270: }
271:
272: }
|