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