    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     * <p>
    022     * Note that as MutableLong does not extend Long, it is not treated by String.format as a Long parameter.
    023     *
    024     * @see Long
    025     * @since 2.1
    026     * @version $Id: MutableLong.java 1160571 2011-08-23 07:36:08Z bayard $
    027     */
    028    public class MutableLong extends Number implements Comparable<MutableLong>, Mutable<Number> {
    029
    030        /**
    031         * Required for serialization support.
    032         *
    033         * @see java.io.Serializable
    034         */
    035        private static final long serialVersionUID = 62986528375L;
    036
    037        /** The mutable value. */
    038        private long value;
    039
    040        /**
    041         * Constructs a new MutableLong with the default value of zero.
    042         */
    043        public MutableLong() {
    044            super();
    045        }
    046
    047        /**
    048         * Constructs a new MutableLong with the specified value.
    049         *
    050         * @param value  the initial value to store
    051         */
    052        public MutableLong(long value) {
    053            super();
    054            this.value = value;
    055        }
    056
    057        /**
    058         * Constructs a new MutableLong with the specified value.
    059         *
    060         * @param value  the initial value to store, not null
    061         * @throws NullPointerException if the object is null
    062         */
    063        public MutableLong(Number value) {
    064            super();
    065            this.value = value.longValue();
    066        }
    067
    068        /**
    069         * Constructs a new MutableLong parsing the given string.
    070         *
    071         * @param value  the string to parse, not null
    072         * @throws NumberFormatException if the string cannot be parsed into a long
    073         * @since 2.5
    074         */
    075        public MutableLong(String value) throws NumberFormatException {
    076            super();
    077            this.value = Long.parseLong(value);
    078        }
    079
    080        //-----------------------------------------------------------------------
    081        /**
    082         * Gets the value as a Long instance.
    083         *
    084         * @return the value as a Long, never null
    085         */
    086        public Long getValue() {
    087            return Long.valueOf(this.value);
    088        }
    089
    090        /**
    091         * Sets the value.
    092         *
    093         * @param value  the value to set
    094         */
    095        public void setValue(long value) {
    096            this.value = value;
    097        }
    098
    099        /**
    100         * Sets the value from any Number instance.
    101         *
    102         * @param value  the value to set, not null
    103         * @throws NullPointerException if the object is null
    104         */
    105        public void setValue(Number value) {
    106            this.value = value.longValue();
    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(long 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.longValue();
    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(long 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.longValue();
    169        }
    170
    171        //-----------------------------------------------------------------------
    172        // shortValue and byteValue rely on Number implementation
    173        /**
    174         * Returns the value of this MutableLong as an int.
    175         *
    176         * @return the numeric value represented by this object after conversion to type int.
    177         */
    178        @Override
    179        public int intValue() {
    180            return (int) value;
    181        }
    182
    183        /**
    184         * Returns the value of this MutableLong as a long.
    185         *
    186         * @return the numeric value represented by this object after conversion to type long.
    187         */
    188        @Override
    189        public long longValue() {
    190            return value;
    191        }
    192
    193        /**
    194         * Returns the value of this MutableLong as a float.
    195         *
    196         * @return the numeric value represented by this object after conversion to type float.
    197         */
    198        @Override
    199        public float floatValue() {
    200            return value;
    201        }
    202
    203        /**
    204         * Returns the value of this MutableLong as a double.
    205         *
    206         * @return the numeric value represented by this object after conversion to type double.
    207         */
    208        @Override
    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, never null
    218         */
    219        public Long toLong() {
    220            return Long.valueOf(longValue());
    221        }
    222
    223        //-----------------------------------------------------------------------
    224        /**
    225         * Compares this object to 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  the object to compare with, null returns false
    230         * @return <code>true</code> if the objects are the same; <code>false</code> otherwise.
    231         */
    232        @Override
    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 hash code for this mutable.
    242         *
    243         * @return a suitable hash code
    244         */
    245        @Override
    246        public int hashCode() {
    247            return (int) (value ^ (value >>> 32));
    248        }
    249
    250        //-----------------------------------------------------------------------
    251        /**
    252         * Compares this mutable to another in ascending order.
    253         *
    254         * @param other  the other mutable to compare to, not null
    255         * @return negative if this is less, zero if equal, positive if greater
    256         */
    257        public int compareTo(MutableLong other) {
    258            long anotherVal = other.value;
    259            return value < anotherVal ? -1 : (value == anotherVal ? 0 : 1);
    260        }
    261
    262        //-----------------------------------------------------------------------
    263        /**
    264         * Returns the String value of this mutable.
    265         *
    266         * @return the mutable value as a string
    267         */
    268        @Override
    269        public String toString() {
    270            return String.valueOf(value);
    271        }
    272
    273    }