| Methods Summary |
|---|
| static java.lang.Byte[] | createBytes()
int len = BYTE_UPPER_BOUND - BYTE_LOWER_BOUND + 1;
Byte [] ret = new Byte [len];
byte val = (byte) BYTE_LOWER_BOUND;
for (int i = 0; i < len; i++, val++) {
ret [i] = Byte.valueOf(val);
}
return ret;
|
| static java.lang.Character[] | createCharacters()
int len = CHARACTER_UPPER_BOUND - CHARACTER_LOWER_BOUND + 1;
Character [] ret = new Character [len];
char val = (char) CHARACTER_LOWER_BOUND;
for (int i = 0; i < len; i++, val++) {
ret [i] = Character.valueOf(val);
}
return ret;
|
| static java.lang.Integer[] | createIntegers()
int len = INTEGER_UPPER_BOUND - INTEGER_LOWER_BOUND + 1;
Integer [] ret = new Integer [len];
int val = (int) INTEGER_LOWER_BOUND;
for (int i = 0; i < len; i++, val++) {
ret [i] = Integer.valueOf(val);
}
return ret;
|
| static java.lang.Long[] | createLongs()
int len = LONG_UPPER_BOUND - LONG_LOWER_BOUND + 1;
Long [] ret = new Long [len];
long val = (long) LONG_LOWER_BOUND;
for (int i = 0; i < len; i++, val++) {
ret [i] = Long.valueOf(val);
}
return ret;
|
| static java.lang.Short[] | createShorts()
int len = SHORT_UPPER_BOUND - SHORT_LOWER_BOUND + 1;
Short [] ret = new Short [len];
short val = (short) SHORT_LOWER_BOUND;
for (int i = 0; i < len; i++, val++) {
ret [i] = Short.valueOf(val);
}
return ret;
|
| public static java.lang.Boolean | getBoolean(boolean pValue)
//-------------------------------------
// Getting primitive values
//-------------------------------------
return
pValue ?
Boolean.TRUE :
Boolean.FALSE;
|
| public static java.lang.Byte | getByte(byte pValue)
if (pValue >= BYTE_LOWER_BOUND &&
pValue <= BYTE_UPPER_BOUND) {
return mBytes [((int) pValue) - BYTE_LOWER_BOUND];
}
else {
return Byte.valueOf(pValue);
}
|
| public static java.lang.Character | getCharacter(char pValue)
if (pValue >= CHARACTER_LOWER_BOUND &&
pValue <= CHARACTER_UPPER_BOUND) {
return mCharacters [((int) pValue) - CHARACTER_LOWER_BOUND];
}
else {
return Character.valueOf(pValue);
}
|
| public static java.lang.Double | getDouble(double pValue)
return Double.valueOf(pValue);
|
| public static java.lang.Float | getFloat(float pValue)
return Float.valueOf(pValue);
|
| public static java.lang.Integer | getInteger(int pValue)
if (pValue >= INTEGER_LOWER_BOUND &&
pValue <= INTEGER_UPPER_BOUND) {
return mIntegers [((int) pValue) - INTEGER_LOWER_BOUND];
}
else {
return Integer.valueOf(pValue);
}
|
| public static java.lang.Long | getLong(long pValue)
if (pValue >= LONG_LOWER_BOUND &&
pValue <= LONG_UPPER_BOUND) {
return mLongs [((int) pValue) - LONG_LOWER_BOUND];
}
else {
return Long.valueOf(pValue);
}
|
| public static java.lang.Class | getPrimitiveObjectClass(java.lang.Class pClass)If the given class is a primitive class, returns the object
version of that class. Otherwise, the class is just returned.
if (pClass == Boolean.TYPE) {
return Boolean.class;
}
else if (pClass == Byte.TYPE) {
return Byte.class;
}
else if (pClass == Short.TYPE) {
return Short.class;
}
else if (pClass == Character.TYPE) {
return Character.class;
}
else if (pClass == Integer.TYPE) {
return Integer.class;
}
else if (pClass == Long.TYPE) {
return Long.class;
}
else if (pClass == Float.TYPE) {
return Float.class;
}
else if (pClass == Double.TYPE) {
return Double.class;
}
else {
return pClass;
}
|
| public static java.lang.Short | getShort(short pValue)
if (pValue >= SHORT_LOWER_BOUND &&
pValue <= SHORT_UPPER_BOUND) {
return mShorts [((int) pValue) - SHORT_LOWER_BOUND];
}
else {
return Short.valueOf(pValue);
}
|
