public static void main(String[] args) {
Number value1 = new Solution().getValueByIndex(5); // -1.0, class java.lang.Double expected
Number value2 = new Solution().getValueByIndex(2); // 3, class java.lang.Integer expected
System.out.println(value1 + ", " + value1.getClass().toString());
System.out.println(value2 + ", " + value2.getClass().toString());
}
public static RangeLookupTable getRangeLookupTable(
List<Range> classificationRanges,
final int[] outputPixelValues,
final Number noDataValue,
final Class<? extends Number> clazz) {
final RangeLookupTable.Builder rltBuilder = new RangeLookupTable.Builder();
final int size = classificationRanges.size();
final boolean useCustomOutputPixelValues =
outputPixelValues != null && outputPixelValues.length == size;
Class<? extends Number> widestClass = noDataValue.getClass();
for (int i = 0; i < size; i++) {
final Range range = classificationRanges.get(i);
final Class<? extends Number> rangeClass = range.getMin().getClass();
if (widestClass != rangeClass) {
widestClass = ClassChanger.getWidestClass(widestClass, rangeClass);
}
final int reference = useCustomOutputPixelValues ? outputPixelValues[i] : i + 1;
rltBuilder.add(range, convert(reference, noDataValue.getClass()));
}
// Add the largest range that contains the no data value
rltBuilder.add(
new Range(getClassMinimum(widestClass), true, getClassMaximum(widestClass), true),
noDataValue);
return rltBuilder.build();
}
/**
* Reads a Number
*
* @return Number Number
*/
@SuppressWarnings({"unchecked", "rawtypes"})
@Override
public Number readNumber(Type target) {
log.debug("readNumber - target: {}", target);
Number v;
if (currentDataType == AMF3.TYPE_NUMBER) {
v = buf.getDouble();
} else {
// we are decoding an int
v = readAMF3Integer();
}
log.debug("readNumber - value: {}", v);
if (target instanceof Class && Number.class.isAssignableFrom((Class<?>) target)) {
Class cls = (Class) target;
if (!cls.isAssignableFrom(v.getClass())) {
String value = v.toString();
log.debug("readNumber - value class: {} str: {}", v.getClass(), value);
if (value.indexOf(".") > 0) {
if (Float.class == v.getClass()) {
v = (Number) convertUtilsBean.convert(value, Float.class);
} else {
v = (Number) convertUtilsBean.convert(value, Double.class);
}
} else {
v = (Number) convertUtilsBean.convert(value, cls);
}
}
}
return v;
}
@Override
public int compare(Pair<V, Number> pairOne, Pair<V, Number> pairTwo) {
Number leftSide = pairOne.getRight();
Number rightSide = pairTwo.getRight();
if (leftSide.getClass() == Double.class) {
Double left = (Double) leftSide;
Double right = (Double) rightSide;
if (left > right) {
return 1;
} else if (right > left) {
return -1;
}
} else if (leftSide.getClass() == Integer.class) {
Integer left = (Integer) leftSide;
Integer right = (Integer) rightSide;
if (left > right) {
return 1;
} else if (right > left) {
return -1;
}
}
return 0;
}
@Override
protected VMRelationalOperator createOperator(Number opOne, Number opTwo) {
throw new VMParsingException(
"Unsupported operOr types "
+ opOne.getClass().getName()
+ ", "
+ opTwo.getClass().getName());
}
public static RangeLookupTable getRangeLookupTable(
final List<Range> classificationRanges,
final int[] outputPixelValues,
final Number noDataValue) {
return getRangeLookupTable(
classificationRanges, outputPixelValues, noDataValue, noDataValue.getClass());
}
/**
* Accepts a number as input and returns its value in byte form in LSB aligned form example: input
* = 5000 [1001110001000] bytes = 19, -120 [00010011] [10001000]
*
* @param Number
* @return byte[]
*/
public static byte[] toByteArray(Number input) {
Class<? extends Number> dataType = input.getClass();
short size = 0;
long longValue = input.longValue();
if (dataType == Byte.class || dataType == byte.class) {
size = Byte.SIZE;
} else if (dataType == Short.class || dataType == short.class) {
size = Short.SIZE;
} else if (dataType == Integer.class || dataType == int.class) {
size = Integer.SIZE;
} else if (dataType == Long.class || dataType == long.class) {
size = Long.SIZE;
} else {
throw new IllegalArgumentException("Parameter must one of the following: Short/Int/Long\n");
}
int length = size / NetUtils.NumBitsInAByte;
byte bytes[] = new byte[length];
// Getting the bytes from input value
for (int i = 0; i < length; i++) {
bytes[i] = (byte) ((longValue >> (NetUtils.NumBitsInAByte * (length - i - 1))) & ByteMask);
}
return bytes;
}
@SuppressWarnings("boxing")
private void cipEqu(Number actual, Number expected, int flags) {
Number res = OverloadedNumberUtil.addFallbackType(actual, flags);
assertEquals(expected.getClass(), res.getClass());
assertEquals(expected, res);
// Some number types wrap the number with multiple types and equals() only compares one of them.
// So we try to
// catch any inconsistency:
assertEquals(expected.byteValue(), res.byteValue());
assertEquals(expected.shortValue(), res.shortValue());
assertEquals(expected.intValue(), res.intValue());
assertEquals(expected.longValue(), res.longValue());
assertEquals(expected.floatValue(), res.floatValue());
assertEquals(expected.doubleValue(), res.doubleValue());
}
private static Object getProperValue(Number number, Class<?> expectedClass) {
Class<?> klazz = ClassUtils.wrapperToPrimitive(number.getClass());
Object value = null;
// Dexlib will only ever make byte (t), int, long (l), or short (s)
if (klazz == byte.class) {
value = number.byteValue();
if (expectedClass == boolean.class) {
value = (byte) value == 1;
}
} else if (klazz == short.class) {
value = number.shortValue();
if (expectedClass == char.class) {
value = (char) number.shortValue();
}
} else if (klazz == int.class) {
if (expectedClass == int.class) {
value = number.intValue();
} else if (expectedClass == float.class) {
value = Float.intBitsToFloat(number.intValue());
}
} else if (klazz == long.class) {
value = number.longValue();
if (expectedClass == long.class) {
value = number.longValue();
} else if (expectedClass == double.class) {
value = Double.longBitsToDouble(number.longValue());
}
}
return value;
}
private AnnotationMirror createNumberAnnotationMirror(List<Number> values) {
if (values.isEmpty()) {
return UNKNOWNVAL;
}
Number first = values.get(0);
if (first instanceof Integer
|| first instanceof Short
|| first instanceof Long
|| first instanceof Byte) {
List<Long> intValues = new ArrayList<>();
for (Number number : values) {
intValues.add(number.longValue());
}
return createIntValAnnotation(intValues);
}
if (first instanceof Double || first instanceof Float) {
List<Double> intValues = new ArrayList<>();
for (Number number : values) {
intValues.add(number.doubleValue());
}
return createDoubleValAnnotation(intValues);
}
throw new UnsupportedOperationException(
"ValueAnnotatedTypeFactory: unexpected class: " + first.getClass());
}
// todo - does this implementation of Number comparison hold?
private int compare(Number number1, Number number2) {
if (!number2.getClass().equals(number1.getClass())) {
throw new IllegalStateException();
}
if (number1 instanceof Comparable) {
return ((Comparable) number1).compareTo(number2);
}
if (number1.doubleValue() < number2.doubleValue()) {
return -1;
}
if (number1.doubleValue() > number2.doubleValue()) {
return 1;
}
return 0;
}
@Override
public Future<V> addAndGetAsync(K key, Number value) {
return commandExecutor.writeAsync(
getName(),
StringCodec.INSTANCE,
new RedisCommand<Object>("HINCRBYFLOAT", new NumberConvertor(value.getClass())),
getName(),
key,
new BigDecimal(value.toString()).toPlainString());
}
private static boolean _equalsForNumbers(Number a, Number b) {
if ((a == null) || (b == null)) return (a == b);
Class<?> ac = a.getClass();
Class<?> bc = b.getClass();
if (ac == bc) return a.equals(b);
if ((ac == Long.class) || (ac == Integer.class) || (ac == Short.class) || (ac == Byte.class))
return _equalsForLong(a.longValue(), b, bc);
if ((ac == Double.class) || (ac == Float.class))
return _equalsForDouble(a.doubleValue(), b, bc);
if (ac == BigInteger.class) return _equalsForBigInteger((BigInteger) a, b, bc);
if (ac == BigDecimal.class) return _equalsForBigDecimal((BigDecimal) a, b, bc);
return a.equals(b);
}
/**
* Create a scalar numeric-valued Attribute.
*
* @param name name of Attribute
* @param val value of Attribute
*/
public Attribute(String name, Number val) {
this.name = name;
int[] shape = new int[1];
shape[0] = 1;
DataType dt = DataType.getType(val.getClass());
Array vala = Array.factory(dt.getPrimitiveClassType(), shape);
Index ima = vala.getIndex();
vala.setDouble(ima.set0(0), val.doubleValue());
setValues(vala);
}
/**
* Called when setting a DECIMAL value internally or from through a procedure or function. Handles
* long in addition to BigDecimal to handle identity being stored as a long but returned as a
* DECIMAL.
*/
public void setValue(Number theValue) throws StandardException {
if (SanityManager.ASSERT) {
if (theValue != null
&& !(theValue instanceof java.math.BigDecimal)
&& !(theValue instanceof java.lang.Long))
SanityManager.THROWASSERT("SQLDecimal.setValue(Number) passed a " + theValue.getClass());
}
if (theValue instanceof BigDecimal || theValue == null) setCoreValue((BigDecimal) theValue);
else setValue(theValue.longValue());
}
public void setStep(Number step) {
Number oldValue = this.step;
this.step = step;
if (this.step.getClass() == oldValue.getClass()) {
this.getModelAsXModel().setStepSize(step);
this.notificarAlteracao(PROP_STEP, oldValue, this.step);
} else {
this.notificarAlteracao(PROP_STEP, oldValue, this.step);
this.setModel(this.alterarModel(step));
}
}
private void serialize(YAMLGenerator yaml, JsonElement e) throws IOException {
switch (e.type()) {
case object:
yaml.writeStartObject();
e.asObject()
.forEach(
(k, v) -> {
try {
yaml.writeFieldName(k);
serialize(yaml, v);
} catch (IOException e1) {
throw new IllegalStateException(e1);
}
});
yaml.writeEndObject();
break;
case array:
yaml.writeStartArray();
e.asArray()
.forEach(
element -> {
try {
serialize(yaml, element);
} catch (IOException e1) {
throw new IllegalStateException(e1);
}
});
yaml.writeEndArray();
break;
case string:
yaml.writeString(e.asString());
break;
case bool:
yaml.writeBoolean(e.asBoolean());
break;
case number:
Number number = e.asNumber();
Class<? extends Number> clazz = number.getClass();
if (clazz.isAssignableFrom(Double.class) || clazz.isAssignableFrom(Float.class)) {
yaml.writeNumber(number.doubleValue());
} else {
yaml.writeNumber(number.longValue());
}
break;
case nullValue:
yaml.writeNull();
break;
default:
break;
}
}
@SuppressWarnings("rawtypes")
static boolean eqNotNull(Number a, Number b) {
Class clazzA = a.getClass();
boolean isIntA = isInt(clazzA);
Class clazzB = a.getClass();
boolean isIntB = isInt(clazzB);
if (isIntA && isIntB) {
return a.longValue() == b.longValue();
}
boolean isDoubleA = isDouble(clazzA);
boolean isDoubleB = isDouble(clazzB);
if ((isDoubleA && isDoubleB) || (isDoubleA && isIntA) || (isDoubleB && isIntA)) {
return a.doubleValue() == b.doubleValue();
}
return false;
}
/**
* Coerces the value to be a number of the specified type; needed because all numbers come back
* from the datastore as Long and this screws up any type that expects something smaller. Also
* does toString just for the hell of it.
*/
Object coerceNumber(Number value, Class<?> type) {
if ((type == Byte.class) || (type == Byte.TYPE)) return value.byteValue();
else if ((type == Short.class) || (type == Short.TYPE)) return value.shortValue();
else if ((type == Integer.class) || (type == Integer.TYPE)) return value.intValue();
else if ((type == Long.class) || (type == Long.TYPE)) return value.longValue();
else if ((type == Float.class) || (type == Float.TYPE)) return value.floatValue();
else if ((type == Double.class) || (type == Double.TYPE)) return value.doubleValue();
else if (type == String.class) return value.toString();
else
throw new IllegalArgumentException(
"Don't know how to convert " + value.getClass() + " to " + type);
}
protected void createNumberField(String name, boolean typify, Number value) {
if (value == null) {
return;
}
String valueString = String.valueOf(value);
createSortableNumericField(name, typify, valueString, value.getClass());
createField(name, valueString);
}
@Override
@SuppressWarnings({"unchecked"})
public Expression<Number> quot(Number number, Expression<? extends Number> expression) {
if (expression == null || number == null) {
throw new IllegalArgumentException("arguments to quot() cannot be null");
}
final Class resultType =
BinaryArithmeticOperation.determineResultType(
number.getClass(), expression.getJavaType(), true);
return new BinaryArithmeticOperation<Number>(
this, resultType, BinaryArithmeticOperation.Operation.DIVIDE, number, expression);
}
@Override
public NumericValue<? extends Number> multiply(NumericValue<? extends Number> other) {
Number otherNumber = other.getValue();
if (otherNumber instanceof Integer) {
return new IntegerValue(value * otherNumber.intValue());
}
if (otherNumber instanceof Double) {
return new DoubleValue(value * otherNumber.doubleValue());
}
if (otherNumber instanceof Long) {
return new LongValue(value * otherNumber.longValue());
}
throw new AssertionError("The type " + otherNumber.getClass() + " was not expected");
}
public void testDefaultConstructor() throws Exception {
MapSpecification.Builder<Number, Integer, Number> builder =
new MapSpecification.Builder<Number, Integer, Number>()
.setJobName("bla")
.setInput(new Input1())
.setMapper(new MapOnlyMapper1())
.setOutput(new Output1());
MapSpecification<Number, Integer, Number> spec = builder.build();
Number result = InProcessMap.runMap(spec).getOutputResult();
assertEquals(Integer.class, result.getClass());
assertEquals(15, result.intValue());
MapOnlyMapper<Number, Integer> mapper = MapOnlyMapper.forMapper(new Mapper1());
builder =
new MapSpecification.Builder<Number, Integer, Number>()
.setJobName("bla")
.setInput(new Input1())
.setMapper(mapper)
.setOutput(new Output1());
spec = builder.build();
result = InProcessMap.runMap(spec).getOutputResult();
assertEquals(Integer.class, result.getClass());
assertEquals(15, result.intValue());
}
protected void putNumber(String name, Number n) {
if (n instanceof Integer
|| n instanceof Short
|| n instanceof Byte
|| n instanceof AtomicInteger) {
_put(NUMBER_INT, name);
_buf.writeInt(n.intValue());
} else if (n instanceof Long || n instanceof AtomicLong) {
_put(NUMBER_LONG, name);
_buf.writeLong(n.longValue());
} else if (n instanceof Float || n instanceof Double) {
_put(NUMBER, name);
_buf.writeDouble(n.doubleValue());
} else {
throw new IllegalArgumentException("can't serialize " + n.getClass());
}
}
private XSpinnerNumberModel alterarModel(Number newStep) {
XSpinnerNumberModel newModel = null;
if (newStep instanceof Integer) {
newModel = new XSpinnerNumberModel.IntXSpinnerNumberModel();
newModel.setExtendedStep(this.getModelAsXModel().getExtendedStep().intValue());
newModel.setMaximum(
(Comparable) (((Number) this.getModelAsXModel().getMaximum()).intValue()));
newModel.setMinimum(
(Comparable) (((Number) this.getModelAsXModel().getMinimum()).intValue()));
newModel.setValue(((Number) this.getModelAsXModel().getMinimum()).intValue());
} else if (newStep instanceof Double) {
newModel = new XSpinnerNumberModel.DoubleXSpinnerNumberModel();
newModel.setExtendedStep(this.getModelAsXModel().getExtendedStep().doubleValue());
newModel.setMaximum(
(Comparable) (((Number) this.getModelAsXModel().getMaximum()).doubleValue()));
newModel.setMinimum(
(Comparable) (((Number) this.getModelAsXModel().getMinimum()).doubleValue()));
newModel.setValue(((Number) this.getModelAsXModel().getMinimum()).doubleValue());
} else if (newStep instanceof BigDecimal) {
newModel = new XSpinnerNumberModel.BigDecimalXSpinnerNumberModel();
newModel.setExtendedStep(
new BigDecimal(this.getModelAsXModel().getExtendedStep().doubleValue()));
newModel.setMaximum(
(Comparable)
(new BigDecimal(((Number) this.getModelAsXModel().getMaximum()).doubleValue())));
newModel.setMinimum(
(Comparable)
(new BigDecimal(((Number) this.getModelAsXModel().getMinimum()).doubleValue())));
newModel.setValue(
new BigDecimal(((Number) this.getModelAsXModel().getMinimum()).doubleValue()));
} else {
throw new IllegalArgumentException(
"Tipo sem NumberModel adequado:" + newStep.getClass().getName());
}
newModel.setStepSize(newStep);
this.extendedStep = newModel.getExtendedStep();
this.maximum = (Number) newModel.getMaximum();
this.minimum = (Number) newModel.getMinimum();
this.setValue(newModel.getValue());
return newModel;
}
/**
* Accepts a number as input and returns its value in byte form in MSB aligned form example: input
* = 5000 [1001110001000] bytes = -114, 64 [10011100] [01000000]
*
* @param Number input
* @param int numBits - the number of bits to be returned
* @return byte[]
*/
public static byte[] toByteArray(Number input, int numBits) {
Class<? extends Number> dataType = input.getClass();
short size = 0;
long longValue = input.longValue();
if (dataType == Short.class) {
size = Short.SIZE;
} else if (dataType == Integer.class) {
size = Integer.SIZE;
} else if (dataType == Long.class) {
size = Long.SIZE;
} else {
throw new IllegalArgumentException("Parameter must one of the following: Short/Int/Long\n");
}
int length = size / NetUtils.NumBitsInAByte;
byte bytes[] = new byte[length];
byte[] inputbytes = new byte[length];
byte shiftedBytes[];
// Getting the bytes from input value
for (int i = 0; i < length; i++) {
bytes[i] = (byte) ((longValue >> (NetUtils.NumBitsInAByte * (length - i - 1))) & ByteMask);
}
if ((bytes[0] == 0 && dataType == Long.class) || (bytes[0] == 0 && dataType == Integer.class)) {
int index = 0;
for (index = 0; index < length; ++index) {
if (bytes[index] != 0) {
bytes[0] = bytes[index];
break;
}
}
System.arraycopy(bytes, index, inputbytes, 0, length - index);
Arrays.fill(bytes, length - index + 1, length - 1, (byte) 0);
} else {
System.arraycopy(bytes, 0, inputbytes, 0, length);
}
shiftedBytes = shiftBitsToMSB(inputbytes, numBits);
return shiftedBytes;
}
private String convertNumber(Number number) {
if (Integer.class.isInstance(number)) {
return NumericUtils.intToPrefixCoded(number.intValue());
} else if (Double.class.isInstance(number)) {
return NumericUtils.doubleToPrefixCoded(number.doubleValue());
} else if (Long.class.isInstance(number)) {
return NumericUtils.longToPrefixCoded(number.longValue());
} else if (Float.class.isInstance(number)) {
return NumericUtils.floatToPrefixCoded(number.floatValue());
} else if (Byte.class.isInstance(number)) {
return NumericUtils.intToPrefixCoded(number.intValue());
} else if (Short.class.isInstance(number)) {
return NumericUtils.intToPrefixCoded(number.intValue());
} else if (BigDecimal.class.isInstance(number)) {
return NumericUtils.doubleToPrefixCoded(number.doubleValue());
} else if (BigInteger.class.isInstance(number)) {
return NumericUtils.longToPrefixCoded(number.longValue());
} else {
throw new IllegalArgumentException("Unsupported numeric type " + number.getClass().getName());
}
}
@Override
public long hash(Number v) {
// have to use a bit of reflection to ensure good hash values since
// we don't have truely type specific stats
if (v instanceof Long) {
return hasher.hashLong(v.longValue()).asLong();
} else if (v instanceof Integer) {
return hasher.hashInt(v.intValue()).asLong();
} else if (v instanceof Double) {
return hasher.hashLong(Double.doubleToRawLongBits(v.doubleValue())).asLong();
} else if (v instanceof Float) {
return hasher.hashInt(Float.floatToRawIntBits(v.floatValue())).asLong();
} else if (v instanceof Byte) {
return hasher.newHasher().putByte(v.byteValue()).hash().asLong();
} else if (v instanceof Short) {
return hasher.newHasher().putShort(v.shortValue()).hash().asLong();
}
// else...
throw new SolrException(
SolrException.ErrorCode.SERVER_ERROR,
"Unsupported Numeric Type (" + v.getClass() + ") for hashing: " + statsField);
}
public static NumericConverter resolveConverter(Number value) {
Class type = value.getClass();
if (Double.class == type) {
return DOUBLE;
}
if (Long.class == type) {
return LONG;
}
if (Float.class == type) {
return FLOAT;
}
if (Integer.class == type) {
return INTEGER;
}
if (Short.class == type) {
return SHORT;
}
if (Byte.class == type) {
return BYTE;
}
return DOUBLE;
}
/**
* Check whether value represents a whole number
*
* @param value
* @return
*/
private static boolean isInt(Number value) {
if (value instanceof Long
|| value instanceof Integer
|| value instanceof Short
|| value instanceof Byte
|| value instanceof BigInteger) {
return true;
}
final BigDecimal bigDecimalValue;
if (value instanceof Double || value instanceof Float) {
bigDecimalValue = new BigDecimal(value.toString());
} else if (value instanceof BigDecimal) {
bigDecimalValue = (BigDecimal) value;
} else {
throw new IllegalArgumentException("Unexpected dataType: " + value.getClass().getName());
}
try {
bigDecimalValue.longValueExact();
return true;
} catch (ArithmeticException e) {
return false;
}
}
