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>long</code> wrapper.
021     * 
022     * @see Long
023     * @since 2.1
024     * @version $Id: MutableLong.java 618693 2008-02-05 16:33:29Z sebb $
025     */
026    public class MutableLong 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 = 62986528375L;
034    
035        /** The mutable value. */
036        private long value;
037    
038        /**
039         * Constructs a new MutableLong with the default value of zero.
040         */
041        public MutableLong() {
042            super();
043        }
044    
045        /**
046         * Constructs a new MutableLong with the specified value.
047         * 
048         * @param value
049         *            a value.
050         */
051        public MutableLong(long value) {
052            super();
053            this.value = value;
054        }
055    
056        /**
057         * Constructs a new MutableLong with the specified value.
058         * 
059         * @param value
060         *            a value.
061         * @throws NullPointerException
062         *             if the object is null
063         */
064        public MutableLong(Number value) {
065            super();
066            this.value = value.longValue();
067        }
068    
069        //-----------------------------------------------------------------------
070        /**
071         * Gets the value as a Long instance.
072         * 
073         * @return the value as a Long
074         */
075        public Object getValue() {
076            return new Long(this.value);
077        }
078    
079        /**
080         * Sets the value.
081         * 
082         * @param value
083         *            the value to set
084         */
085        public void setValue(long 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).longValue());
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(long 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.longValue();
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(long 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.longValue();
173        }
174    
175        //-----------------------------------------------------------------------
176        // shortValue and bytValue rely on Number implementation
177        /**
178         * Returns the value of this MutableLong 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 (int) value;
184        }
185    
186        /**
187         * Returns the value of this MutableLong 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 MutableLong 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 MutableLong 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 Long.
216         *
217         * @return a Long instance containing the value from this mutable
218         */
219        public Long toLong() {
220            return new Long(longValue());
221        }
222    
223        //-----------------------------------------------------------------------
224        /**
225         * Compares this object against the specified object. The result is <code>true</code> if and only if the argument
226         * is not <code>null</code> and is a <code>MutableLong</code> object that contains the same <code>long</code>
227         * value 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 MutableLong) {
235                return value == ((MutableLong) obj).longValue();
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 (int) (value ^ (value >>> 32));
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 MutableLong
256         */
257        public int compareTo(Object obj) {
258            MutableLong other = (MutableLong) obj;
259            long 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    }