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: * @version $Id: MutableByte.java 437554 2006-08-28 06:21:41Z bayard $
025: */
026: public class MutableByte 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 = -1585823265L;
034:
035: /** The mutable value. */
036: private byte value;
037:
038: /**
039: * Constructs a new MutableByte with the default value of zero.
040: */
041: public MutableByte() {
042: super ();
043: }
044:
045: /**
046: * Constructs a new MutableByte with the specified value.
047: *
048: * @param value
049: * a value.
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
060: * a value.
061: * @throws NullPointerException
062: * if the object is null
063: */
064: public MutableByte(Number value) {
065: super ();
066: this .value = value.byteValue();
067: }
068:
069: //-----------------------------------------------------------------------
070: /**
071: * Gets the value as a Byte instance.
072: *
073: * @return the value as a Byte
074: */
075: public Object getValue() {
076: return new Byte(this .value);
077: }
078:
079: /**
080: * Sets the value.
081: *
082: * @param value
083: * the value to set
084: */
085: public void setValue(byte 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).byteValue());
101: }
102:
103: //-----------------------------------------------------------------------
104: // shortValue relies on Number implementation
105: /**
106: * Returns the value of this MutableByte as a byte.
107: *
108: * @return the numeric value represented by this object after conversion to type byte.
109: */
110: public byte byteValue() {
111: return value;
112: }
113:
114: /**
115: * Returns the value of this MutableByte as a int.
116: *
117: * @return the numeric value represented by this object after conversion to type int.
118: */
119: public int intValue() {
120: return value;
121: }
122:
123: /**
124: * Returns the value of this MutableByte as a long.
125: *
126: * @return the numeric value represented by this object after conversion to type long.
127: */
128: public long longValue() {
129: return value;
130: }
131:
132: /**
133: * Returns the value of this MutableByte as a float.
134: *
135: * @return the numeric value represented by this object after conversion to type float.
136: */
137: public float floatValue() {
138: return value;
139: }
140:
141: /**
142: * Returns the value of this MutableByte as a double.
143: *
144: * @return the numeric value represented by this object after conversion to type double.
145: */
146: public double doubleValue() {
147: return value;
148: }
149:
150: //-----------------------------------------------------------------------
151: /**
152: * Gets this mutable as an instance of Byte.
153: *
154: * @return a Byte instance containing the value from this mutable
155: */
156: public Byte toByte() {
157: return new Byte(byteValue());
158: }
159:
160: //-----------------------------------------------------------------------
161: /**
162: * Increments the value.
163: *
164: * @since Commons Lang 2.2
165: */
166: public void increment() {
167: value++;
168: }
169:
170: /**
171: * Decrements the value.
172: *
173: * @since Commons Lang 2.2
174: */
175: public void decrement() {
176: value--;
177: }
178:
179: //-----------------------------------------------------------------------
180: /**
181: * Adds a value.
182: *
183: * @param operand
184: * the value to add
185: *
186: * @since Commons Lang 2.2
187: */
188: public void add(byte operand) {
189: this .value += operand;
190: }
191:
192: /**
193: * Adds a value.
194: *
195: * @param operand
196: * the value to add
197: * @throws NullPointerException
198: * if the object is null
199: *
200: * @since Commons Lang 2.2
201: */
202: public void add(Number operand) {
203: this .value += operand.byteValue();
204: }
205:
206: /**
207: * Subtracts a value.
208: *
209: * @param operand
210: * the value to add
211: *
212: * @since Commons Lang 2.2
213: */
214: public void subtract(byte operand) {
215: this .value -= operand;
216: }
217:
218: /**
219: * Subtracts a value.
220: *
221: * @param operand
222: * the value to add
223: * @throws NullPointerException
224: * if the object is null
225: *
226: * @since Commons Lang 2.2
227: */
228: public void subtract(Number operand) {
229: this .value -= operand.byteValue();
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>MutableByte</code> object that contains the same <code>byte</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 MutableByte) {
244: return value == ((MutableByte) obj).byteValue();
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 MutableByte
265: */
266: public int compareTo(Object obj) {
267: MutableByte other = (MutableByte) obj;
268: byte 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: }
|