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 618693 2008-02-05 16:33:29Z sebb $ 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 }