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     * @author Apache Software Foundation
025     * @version $Id: MutableInt.java 905707 2010-02-02 16:59:59Z niallp $
026     */
027    public class MutableInt extends Number implements Comparable, Mutable {
028    
029        /**
030         * Required for serialization support.
031         * 
032         * @see java.io.Serializable
033         */
034        private static final long serialVersionUID = 512176391864L;
035    
036        /** The mutable value. */
037        private int value;
038    
039        /**
040         * Constructs a new MutableInt with the default value of zero.
041         */
042        public MutableInt() {
043            super();
044        }
045    
046        /**
047         * Constructs a new MutableInt with the specified value.
048         * 
049         * @param value  the initial value to store
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  the initial value to store, not null
060         * @throws NullPointerException if the object is null
061         */
062        public MutableInt(Number value) {
063            super();
064            this.value = value.intValue();
065        }
066    
067        /**
068         * Constructs a new MutableInt parsing the given string.
069         * 
070         * @param value  the string to parse, not null
071         * @throws NumberFormatException if the string cannot be parsed into an int
072         * @since 2.5
073         */
074        public MutableInt(String value) throws NumberFormatException {
075            super();
076            this.value = Integer.parseInt(value);
077        }
078    
079        //-----------------------------------------------------------------------
080        /**
081         * Gets the value as a Integer instance.
082         * 
083         * @return the value as a Integer, never null
084         */
085        public Object getValue() {
086            return new Integer(this.value);
087        }
088    
089        /**
090         * Sets the value.
091         * 
092         * @param value  the value to set
093         */
094        public void setValue(int value) {
095            this.value = value;
096        }
097    
098        /**
099         * Sets the value from any Number instance.
100         * 
101         * @param value  the value to set, not null
102         * @throws NullPointerException if the object is null
103         * @throws ClassCastException if the type is not a {@link Number}
104         */
105        public void setValue(Object value) {
106            setValue(((Number) value).intValue());
107        }
108    
109        //-----------------------------------------------------------------------
110        /**
111         * Increments the value.
112         *
113         * @since Commons Lang 2.2
114         */
115        public void increment() {
116            value++;
117        }
118    
119        /**
120         * Decrements the value.
121         *
122         * @since Commons Lang 2.2
123         */
124        public void decrement() {
125            value--;
126        }
127    
128        //-----------------------------------------------------------------------
129        /**
130         * Adds a value to the value of this instance.
131         * 
132         * @param operand  the value to add, not null
133         * @since Commons Lang 2.2
134         */
135        public void add(int operand) {
136            this.value += operand;
137        }
138    
139        /**
140         * Adds a value to the value of this instance.
141         * 
142         * @param operand  the value to add, not null
143         * @throws NullPointerException if the object is null
144         * @since Commons Lang 2.2
145         */
146        public void add(Number operand) {
147            this.value += operand.intValue();
148        }
149    
150        /**
151         * Subtracts a value from the value of this instance.
152         * 
153         * @param operand  the value to subtract, not null
154         * @since Commons Lang 2.2
155         */
156        public void subtract(int operand) {
157            this.value -= operand;
158        }
159    
160        /**
161         * Subtracts a value from the value of this instance.
162         * 
163         * @param operand  the value to subtract, not null
164         * @throws NullPointerException if the object is null
165         * @since Commons Lang 2.2
166         */
167        public void subtract(Number operand) {
168            this.value -= operand.intValue();
169        }
170    
171        //-----------------------------------------------------------------------
172        // shortValue and bytValue rely on Number implementation
173        /**
174         * Returns the value of this MutableInt as an int.
175         *
176         * @return the numeric value represented by this object after conversion to type int.
177         */
178        public int intValue() {
179            return value;
180        }
181    
182        /**
183         * Returns the value of this MutableInt as a long.
184         *
185         * @return the numeric value represented by this object after conversion to type long.
186         */
187        public long longValue() {
188            return value;
189        }
190    
191        /**
192         * Returns the value of this MutableInt as a float.
193         *
194         * @return the numeric value represented by this object after conversion to type float.
195         */
196        public float floatValue() {
197            return value;
198        }
199    
200        /**
201         * Returns the value of this MutableInt as a double.
202         *
203         * @return the numeric value represented by this object after conversion to type double.
204         */
205        public double doubleValue() {
206            return value;
207        }
208    
209        //-----------------------------------------------------------------------
210        /**
211         * Gets this mutable as an instance of Integer.
212         *
213         * @return a Integer instance containing the value from this mutable, never null
214         */
215        public Integer toInteger() {
216            return new Integer(intValue());
217        }
218    
219        //-----------------------------------------------------------------------
220        /**
221         * Compares this object to the specified object. The result is <code>true</code> if and only if the argument is
222         * not <code>null</code> and is a <code>MutableInt</code> object that contains the same <code>int</code> value
223         * as this object.
224         * 
225         * @param obj  the object to compare with, null returns false
226         * @return <code>true</code> if the objects are the same; <code>false</code> otherwise.
227         */
228        public boolean equals(Object obj) {
229            if (obj instanceof MutableInt) {
230                return value == ((MutableInt) obj).intValue();
231            }
232            return false;
233        }
234    
235        /**
236         * Returns a suitable hash code for this mutable.
237         * 
238         * @return a suitable hash code
239         */
240        public int hashCode() {
241            return value;
242        }
243    
244        //-----------------------------------------------------------------------
245        /**
246         * Compares this mutable to another in ascending order.
247         * 
248         * @param obj the other mutable to compare to, not null
249         * @return negative if this is less, zero if equal, positive if greater
250         * @throws ClassCastException if the argument is not a MutableInt
251         */
252        public int compareTo(Object obj) {
253            MutableInt other = (MutableInt) obj;
254            int anotherVal = other.value;
255            return value < anotherVal ? -1 : (value == anotherVal ? 0 : 1);
256        }
257    
258        //-----------------------------------------------------------------------
259        /**
260         * Returns the String value of this mutable.
261         * 
262         * @return the mutable value as a string
263         */
264        public String toString() {
265            return String.valueOf(value);
266        }
267    
268    }