1 /*
2 * Licensed to the Apache Software Foundation (ASF) under one or more
3 * contributor license agreements. See the NOTICE file distributed with
4 * this work for additional information regarding copyright ownership.
5 * The ASF licenses this file to You under the Apache License, Version 2.0
6 * (the "License"); you may not use this file except in compliance with
7 * the License. You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17 package org.apache.commons.lang3.mutable;
18
19 import org.apache.commons.lang3.math.NumberUtils;
20
21 /**
22 * A mutable {@code short} wrapper.
23 * <p>
24 * Note that as MutableShort does not extend Short, it is not treated by String.format as a Short parameter.
25 * </p>
26 *
27 * @see Short
28 * @since 2.1
29 */
30 public class MutableShort extends Number implements Comparable<MutableShort>, Mutable<Number> {
31
32 /**
33 * Required for serialization support.
34 *
35 * @see java.io.Serializable
36 */
37 private static final long serialVersionUID = -2135791679L;
38
39 /** The mutable value. */
40 private short value;
41
42 /**
43 * Constructs a new MutableShort with the default value of zero.
44 */
45 public MutableShort() {
46 }
47
48 /**
49 * Constructs a new MutableShort with the specified value.
50 *
51 * @param value the initial value to store, not null
52 * @throws NullPointerException if the object is null
53 */
54 public MutableShort(final Number value) {
55 this.value = value.shortValue();
56 }
57
58 /**
59 * Constructs a new MutableShort with the specified value.
60 *
61 * @param value the initial value to store
62 */
63 public MutableShort(final short value) {
64 this.value = value;
65 }
66
67 /**
68 * Constructs a new MutableShort parsing the given string.
69 *
70 * @param value the string to parse, not null
71 * @throws NumberFormatException if the string cannot be parsed into a short
72 * @since 2.5
73 */
74 public MutableShort(final String value) {
75 this.value = Short.parseShort(value);
76 }
77
78 /**
79 * Adds a value to the value of this instance.
80 *
81 * @param operand the value to add, not null
82 * @throws NullPointerException if the object is null
83 * @since 2.2
84 */
85 public void add(final Number operand) {
86 this.value += operand.shortValue();
87 }
88
89 /**
90 * Adds a value to the value of this instance.
91 *
92 * @param operand the value to add, not null
93 * @since 2.2
94 */
95 public void add(final short operand) {
96 this.value += operand;
97 }
98
99 /**
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 }