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