    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 *      https://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 */
    017package org.apache.commons.lang3.mutable;
    018
    019import java.util.concurrent.atomic.AtomicInteger;
    020
    021/**
    022 * A mutable {@code short} wrapper.
    023 * <p>
    024 * This class was created before the introduction of the the {@link java.util.concurrent.atomic} package and the {@link AtomicInteger} class.
    025 * </p>
    026 * <p>
    027 * Note that as MutableShort does not extend Short, it is not treated by String.format as a Short parameter.
    028 * </p>
    029 *
    030 * @see Short
    031 * @see AtomicInteger
    032 * @since 2.1
    033 */
    034public class MutableShort extends Number implements Comparable<MutableShort>, Mutable<Number> {
    035
    036    /**
    037     * Required for serialization support.
    038     *
    039     * @see java.io.Serializable
    040     */
    041    private static final long serialVersionUID = -2135791679L;
    042
    043    /** The mutable value. */
    044    private short value;
    045
    046    /**
    047     * Constructs a new MutableShort with the default value of zero.
    048     */
    049    public MutableShort() {
    050    }
    051
    052    /**
    053     * Constructs a new MutableShort with the specified value.
    054     *
    055     * @param value  the initial value to store, not null.
    056     * @throws NullPointerException if the object is null.
    057     */
    058    public MutableShort(final Number value) {
    059        this.value = value.shortValue();
    060    }
    061
    062    /**
    063     * Constructs a new MutableShort with the specified value.
    064     *
    065     * @param value  the initial value to store.
    066     */
    067    public MutableShort(final short value) {
    068        this.value = value;
    069    }
    070
    071    /**
    072     * Constructs a new MutableShort parsing the given string.
    073     *
    074     * @param value  the string to parse, not null.
    075     * @throws NumberFormatException if the string cannot be parsed into a short, see {@link Short#parseShort(String)}.
    076     * @since 2.5
    077     */
    078    public MutableShort(final String value) {
    079        this.value = Short.parseShort(value);
    080    }
    081
    082    /**
    083     * Adds a value to the value of this instance.
    084     *
    085     * @param operand  the value to add, not null.
    086     * @throws NullPointerException if the object is null.
    087     * @since 2.2
    088     */
    089    public void add(final Number operand) {
    090        this.value += operand.shortValue();
    091    }
    092
    093    /**
    094     * Adds a value to the value of this instance.
    095     *
    096     * @param operand  the value to add, not null.
    097     * @since 2.2
    098     */
    099    public void add(final short operand) {
    100        this.value += operand;
    101    }
    102
    103    /**
    104     * Increments this instance's value by {@code operand}; this method returns the value associated with the instance
    105     * immediately after the addition operation. This method is not thread safe.
    106     *
    107     * @param operand the quantity to add, not null.
    108     * @throws NullPointerException if {@code operand} is null.
    109     * @return the value associated with this instance after adding the operand.
    110     * @since 3.5
    111     */
    112    public short addAndGet(final Number operand) {
    113        this.value += operand.shortValue();
    114        return value;
    115    }
    116
    117    /**
    118     * Increments this instance's value by {@code operand}; this method returns the value associated with the instance
    119     * immediately after the addition operation. This method is not thread safe.
    120     *
    121     * @param operand the quantity to add, not null.
    122     * @return the value associated with this instance after adding the operand.
    123     * @since 3.5
    124     */
    125    public short addAndGet(final short operand) {
    126        this.value += operand;
    127        return value;
    128    }
    129
    130    /**
    131     * Compares this mutable to another in ascending order.
    132     *
    133     * @param other  the other mutable to compare to, not null.
    134     * @return negative if this is less, zero if equal, positive if greater.
    135     */
    136    @Override
    137    public int compareTo(final MutableShort other) {
    138        return Short.compare(this.value, other.value);
    139    }
    140
    141    /**
    142     * Decrements the value.
    143     *
    144     * @since 2.2
    145     */
    146    public void decrement() {
    147        value--;
    148    }
    149
    150    /**
    151     * Decrements this instance's value by 1; this method returns the value associated with the instance
    152     * immediately after the decrement operation. This method is not thread safe.
    153     *
    154     * @return the value associated with the instance after it is decremented.
    155     * @since 3.5
    156     */
    157    public short decrementAndGet() {
    158        value--;
    159        return value;
    160    }
    161
    162    /**
    163     * Returns the value of this MutableShort as a double.
    164     *
    165     * @return the numeric value represented by this object after conversion to type double.
    166     */
    167    @Override
    168    public double doubleValue() {
    169        return value;
    170    }
    171
    172    /**
    173     * Compares this object to the specified object. The result is {@code true} if and only if the argument
    174     * is not {@code null} and is a {@link MutableShort} object that contains the same {@code short}
    175     * value as this object.
    176     *
    177     * @param obj  the object to compare with, null returns false.
    178     * @return {@code true} if the objects are the same; {@code false} otherwise.
    179     */
    180    @Override
    181    public boolean equals(final Object obj) {
    182        if (obj instanceof MutableShort) {
    183            return value == ((MutableShort) obj).shortValue();
    184        }
    185        return false;
    186    }
    187
    188    /**
    189     * Returns the value of this MutableShort as a float.
    190     *
    191     * @return the numeric value represented by this object after conversion to type float.
    192     */
    193    @Override
    194    public float floatValue() {
    195        return value;
    196    }
    197
    198    /**
    199     * Increments this instance's value by {@code operand}; this method returns the value associated with the instance
    200     * immediately prior to the addition operation. This method is not thread safe.
    201     *
    202     * @param operand the quantity to add, not null.
    203     * @throws NullPointerException if {@code operand} is null.
    204     * @return the value associated with this instance immediately before the operand was added.
    205     * @since 3.5
    206     */
    207    public short getAndAdd(final Number operand) {
    208        final short last = value;
    209        this.value += operand.shortValue();
    210        return last;
    211    }
    212
    213    /**
    214     * Increments this instance's value by {@code operand}; this method returns the value associated with the instance
    215     * immediately prior to the addition operation. This method is not thread safe.
    216     *
    217     * @param operand the quantity to add, not null.
    218     * @return the value associated with this instance immediately before the operand was added.
    219     * @since 3.5
    220     */
    221    public short getAndAdd(final short operand) {
    222        final short last = value;
    223        this.value += operand;
    224        return last;
    225    }
    226
    227    /**
    228     * Decrements this instance's value by 1; this method returns the value associated with the instance
    229     * immediately prior to the decrement operation. This method is not thread safe.
    230     *
    231     * @return the value associated with the instance before it was decremented.
    232     * @since 3.5
    233     */
    234    public short getAndDecrement() {
    235        final short last = value;
    236        value--;
    237        return last;
    238    }
    239
    240    /**
    241     * Increments this instance's value by 1; this method returns the value associated with the instance
    242     * immediately prior to the increment operation. This method is not thread safe.
    243     *
    244     * @return the value associated with the instance before it was incremented.
    245     * @since 3.5
    246     */
    247    public short getAndIncrement() {
    248        final short last = value;
    249        value++;
    250        return last;
    251    }
    252
    253    /**
    254     * Gets the value as a Short instance.
    255     *
    256     * @return the value as a Short, never null.
    257     * @deprecated Use {@link #get()}.
    258     */
    259    @Deprecated
    260    @Override
    261    public Short getValue() {
    262        return Short.valueOf(this.value);
    263    }
    264
    265    /**
    266     * Returns a suitable hash code for this mutable.
    267     *
    268     * @return a suitable hash code.
    269     */
    270    @Override
    271    public int hashCode() {
    272        return value;
    273    }
    274
    275    /**
    276     * Increments the value.
    277     *
    278     * @since 2.2
    279     */
    280    public void increment() {
    281        value++;
    282    }
    283
    284    /**
    285     * Increments this instance's value by 1; this method returns the value associated with the instance
    286     * immediately after the increment operation. This method is not thread safe.
    287     *
    288     * @return the value associated with the instance after it is incremented.
    289     * @since 3.5
    290     */
    291    public short incrementAndGet() {
    292        value++;
    293        return value;
    294    }
    295
    296    /**
    297     * Returns the value of this MutableShort as an int.
    298     *
    299     * @return the numeric value represented by this object after conversion to type int.
    300     */
    301    @Override
    302    public int intValue() {
    303        return value;
    304    }
    305
    306    /**
    307     * Returns the value of this MutableShort as a long.
    308     *
    309     * @return the numeric value represented by this object after conversion to type long.
    310     */
    311    @Override
    312    public long longValue() {
    313        return value;
    314    }
    315
    316    /**
    317     * Sets the value from any Number instance.
    318     *
    319     * @param value  the value to set, not null.
    320     * @throws NullPointerException if the object is null.
    321     */
    322    @Override
    323    public void setValue(final Number value) {
    324        this.value = value.shortValue();
    325    }
    326
    327    /**
    328     * Sets the value.
    329     *
    330     * @param value  the value to set
    331     */
    332    public void setValue(final short value) {
    333        this.value = value;
    334    }
    335
    336    // byteValue relies on Number implementation
    337    /**
    338     * Returns the value of this MutableShort as a short.
    339     *
    340     * @return the numeric value represented by this object after conversion to type short.
    341     */
    342    @Override
    343    public short shortValue() {
    344        return value;
    345    }
    346
    347    /**
    348     * Subtracts a value from the value of this instance.
    349     *
    350     * @param operand  the value to subtract, not null.
    351     * @throws NullPointerException if the object is null.
    352     * @since 2.2
    353     */
    354    public void subtract(final Number operand) {
    355        this.value -= operand.shortValue();
    356    }
    357
    358    /**
    359     * Subtracts a value from the value of this instance.
    360     *
    361     * @param operand  the value to subtract, not null.
    362     * @since 2.2
    363     */
    364    public void subtract(final short operand) {
    365        this.value -= operand;
    366    }
    367
    368    /**
    369     * Gets this mutable as an instance of Short.
    370     *
    371     * @return a Short instance containing the value from this mutable, never null.
    372     */
    373    public Short toShort() {
    374        return Short.valueOf(shortValue());
    375    }
    376
    377    /**
    378     * Returns the String value of this mutable.
    379     *
    380     * @return the mutable value as a string.
    381     */
    382    @Override
    383    public String toString() {
    384        return String.valueOf(value);
    385    }
    386
    387}