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>byte</code> wrapper.
021 *
022 * @see Byte
023 * @since 2.1
024 * @author Apache Software Foundation
025 * @version $Id: MutableByte.java 905707 2010-02-02 16:59:59Z niallp $
026 */
027 public class MutableByte extends Number implements Comparable, Mutable {
028
029 /**
030 * Required for serialization support.
031 *
032 * @see java.io.Serializable
033 */
034 private static final long serialVersionUID = -1585823265L;
035
036 /** The mutable value. */
037 private byte value;
038
039 /**
040 * Constructs a new MutableByte with the default value of zero.
041 */
042 public MutableByte() {
043 super();
044 }
045
046 /**
047 * Constructs a new MutableByte with the specified value.
048 *
049 * @param value the initial value to store
050 */
051 public MutableByte(byte value) {
052 super();
053 this.value = value;
054 }
055
056 /**
057 * Constructs a new MutableByte with the specified value.
058 *
059 * @param value the initial value to store, not null
060 * @throws NullPointerException if the object is null
061 */
062 public MutableByte(Number value) {
063 super();
064 this.value = value.byteValue();
065 }
066
067 /**
068 * Constructs a new MutableByte 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 byte
072 * @since 2.5
073 */
074 public MutableByte(String value) throws NumberFormatException {
075 super();
076 this.value = Byte.parseByte(value);
077 }
078
079 //-----------------------------------------------------------------------
080 /**
081 * Gets the value as a Byte instance.
082 *
083 * @return the value as a Byte, never null
084 */
085 public Object getValue() {
086 return new Byte(this.value);
087 }
088
089 /**
090 * Sets the value.
091 *
092 * @param value the value to set
093 */
094 public void setValue(byte value) {
095 this.value = value;
096 }
097
098 /**
099 * Sets the value from any Number instance.
100 *
101 * @param value the value to set, not null
102 * @throws NullPointerException if the object is null
103 * @throws ClassCastException if the type is not a {@link Number}
104 */
105 public void setValue(Object value) {
106 setValue(((Number) value).byteValue());
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(byte 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.byteValue();
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(byte 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.byteValue();
169 }
170
171 //-----------------------------------------------------------------------
172 // shortValue relies on Number implementation
173 /**
174 * Returns the value of this MutableByte as a byte.
175 *
176 * @return the numeric value represented by this object after conversion to type byte.
177 */
178 public byte byteValue() {
179 return value;
180 }
181
182 /**
183 * Returns the value of this MutableByte as an int.
184 *
185 * @return the numeric value represented by this object after conversion to type int.
186 */
187 public int intValue() {
188 return value;
189 }
190
191 /**
192 * Returns the value of this MutableByte as a long.
193 *
194 * @return the numeric value represented by this object after conversion to type long.
195 */
196 public long longValue() {
197 return value;
198 }
199
200 /**
201 * Returns the value of this MutableByte as a float.
202 *
203 * @return the numeric value represented by this object after conversion to type float.
204 */
205 public float floatValue() {
206 return value;
207 }
208
209 /**
210 * Returns the value of this MutableByte as a double.
211 *
212 * @return the numeric value represented by this object after conversion to type double.
213 */
214 public double doubleValue() {
215 return value;
216 }
217
218 //-----------------------------------------------------------------------
219 /**
220 * Gets this mutable as an instance of Byte.
221 *
222 * @return a Byte instance containing the value from this mutable
223 */
224 public Byte toByte() {
225 return new Byte(byteValue());
226 }
227
228 //-----------------------------------------------------------------------
229 /**
230 * Compares this object to the specified object. The result is <code>true</code> if and only if the argument is
231 * not <code>null</code> and is a <code>MutableByte</code> object that contains the same <code>byte</code> value
232 * as this object.
233 *
234 * @param obj the object to compare with, null returns false
235 * @return <code>true</code> if the objects are the same; <code>false</code> otherwise.
236 */
237 public boolean equals(Object obj) {
238 if (obj instanceof MutableByte) {
239 return value == ((MutableByte) obj).byteValue();
240 }
241 return false;
242 }
243
244 /**
245 * Returns a suitable hash code for this mutable.
246 *
247 * @return a suitable hash code
248 */
249 public int hashCode() {
250 return value;
251 }
252
253 //-----------------------------------------------------------------------
254 /**
255 * Compares this mutable to another in ascending order.
256 *
257 * @param obj the other mutable to compare to, not null
258 * @return negative if this is less, zero if equal, positive if greater
259 * @throws ClassCastException if the argument is not a MutableByte
260 */
261 public int compareTo(Object obj) {
262 MutableByte other = (MutableByte) obj;
263 byte anotherVal = other.value;
264 return value < anotherVal ? -1 : (value == anotherVal ? 0 : 1);
265 }
266
267 //-----------------------------------------------------------------------
268 /**
269 * Returns the String value of this mutable.
270 *
271 * @return the mutable value as a string
272 */
273 public String toString() {
274 return String.valueOf(value);
275 }
276
277 }