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