@Override public double readDouble(int ordinal, int fieldIndex) { return ((HollowObjectTypeDataAccess) currentDataAccess).readDouble(ordinal, fieldIndex); }
public Double getValueBoxed(int ordinal) { double d; if(fieldIndex[0] == -1) { d = missingDataHandler().handleDouble("Double", ordinal, "value"); } else { boxedFieldAccessSampler.recordFieldAccess(fieldIndex[0]); d = getTypeDataAccess().readDouble(ordinal, fieldIndex[0]); } return Double.isNaN(d) ? null : Double.valueOf(d); }
public double getValue(int ordinal) { if(fieldIndex[0] == -1) return missingDataHandler().handleDouble("Double", ordinal, "value"); return getTypeDataAccess().readDouble(ordinal, fieldIndex[0]); }
private void appendFieldStringify(Writer writer, HollowDataAccess dataAccess, int indentation, HollowObjectSchema schema, HollowObjectTypeDataAccess typeDataAccess, int ordinal, int fieldIdx) throws IOException { switch(schema.getFieldType(fieldIdx)) { case BOOLEAN: writer.append(typeDataAccess.readBoolean(ordinal, fieldIdx).booleanValue() ? "true" : "false"); return; case BYTES: writer.append(Arrays.toString(typeDataAccess.readBytes(ordinal, fieldIdx))); return; case DOUBLE: writer.append(String.valueOf(typeDataAccess.readDouble(ordinal, fieldIdx))); return; case FLOAT: writer.append(String.valueOf(typeDataAccess.readFloat(ordinal, fieldIdx))); return; case INT: writer.append(String.valueOf(typeDataAccess.readInt(ordinal, fieldIdx))); return; case LONG: writer.append(String.valueOf(typeDataAccess.readLong(ordinal, fieldIdx))); return; case STRING: writer.append("\"").append(escapeString(typeDataAccess.readString(ordinal, fieldIdx))).append("\""); return; case REFERENCE: int refOrdinal = typeDataAccess.readOrdinal(ordinal, fieldIdx); appendStringify(writer, dataAccess, schema.getReferencedType(fieldIdx), refOrdinal, indentation); return; } }
/** * @param typeAccess the type access * @param ordinal the ordinal * @param fieldPosition the field position * @return a displayable String for a field from an OBJECT record. */ public static String displayString(HollowObjectTypeDataAccess typeAccess, int ordinal, int fieldPosition) { HollowObjectSchema schema = typeAccess.getSchema(); switch(schema.getFieldType(fieldPosition)) { case BOOLEAN: Boolean bool = typeAccess.readBoolean(ordinal, fieldPosition); String.valueOf(bool); case BYTES: case STRING: return typeAccess.readString(ordinal, fieldPosition); case DOUBLE: double d = typeAccess.readDouble(ordinal, fieldPosition); return String.valueOf(d); case FLOAT: float f = typeAccess.readFloat(ordinal, fieldPosition); return String.valueOf(f); case INT: return String.valueOf(typeAccess.readInt(ordinal, fieldPosition)); case LONG: long l = typeAccess.readLong(ordinal, fieldPosition); return String.valueOf(l); default: } throw new IllegalStateException("I don't know how to display a " + schema.getFieldType(fieldPosition)); }
return typeAccess.readString(ordinal, fieldPosition); case DOUBLE: double d = typeAccess.readDouble(ordinal, fieldPosition); return Double.isNaN(d) ? null : Double.valueOf(d); case FLOAT:
return Arrays.equals(dataAccess.readBytes(ordinal, lastFieldIdx), (byte[])key); case DOUBLE: return dataAccess.readDouble(ordinal, lastFieldIdx) == ((Double)key).doubleValue(); case FLOAT: return dataAccess.readFloat(ordinal, lastFieldIdx) == ((Float)key).floatValue();
private Object readFromObject(HollowObjectTypeDataAccess objectTypeDataAccess, int ordinal, FieldType fieldType, int fieldPosition) { Object value; switch (fieldType) { case INT: value = objectTypeDataAccess.readInt(ordinal, fieldPosition); break; case LONG: value = objectTypeDataAccess.readLong(ordinal, fieldPosition); break; case DOUBLE: value = objectTypeDataAccess.readDouble(ordinal, fieldPosition); break; case FLOAT: value = objectTypeDataAccess.readFloat(ordinal, fieldPosition); break; case BOOLEAN: value = objectTypeDataAccess.readBoolean(ordinal, fieldPosition); break; case STRING: value = objectTypeDataAccess.readString(ordinal, fieldPosition); break; default: throw new IllegalStateException("Invalid field type :" + fieldType + " cannot read values for this type"); } return value; } }
case DOUBLE: if(testObject instanceof Double) return testObject.equals(typeAccess.readDouble(ordinal, fieldPosition)); return testObject == null && !Double.isNaN(typeAccess.readDouble(ordinal, fieldPosition)); case FLOAT: if(testObject instanceof Float)
break; case DOUBLE: values.add(objectAccess.readDouble(ordinals.get(i), fieldIdx)); break; case FLOAT:
@Override public double getDouble(int ordinal, String fieldName) { HollowObjectTypeDataAccess dataAccess = getTypeDataAccess(); int fieldIndex = getSchema().getPosition(fieldName); if(fieldIndex == -1) return missingDataHandler().handleDouble(getSchema().getName(), ordinal, fieldName); return dataAccess.readDouble(ordinal, fieldIndex); }
return Arrays.equals(data1, data2); case DOUBLE: double d1 = typeAccess1.readDouble(ordinal1, fieldPosition1); double d2 = typeAccess2.readDouble(ordinal2, fieldPosition2); return Double.compare(d1, d2) == 0; case FLOAT:
break; case DOUBLE: fieldValue = Double.valueOf(typeDataAccess.readDouble(effigy.ordinal, i)); break; case FLOAT:
@Override public double readDouble(int ordinal, int fieldIndex) { sampler().recordFieldAccess(fieldIndex); recordStackTrace(); if(!ordinalIsPresent(ordinal)) return ((HollowObjectTypeDataAccess)dataAccess.getTypeDataAccess(getSchema().getName(), ordinal)).readDouble(ordinal, fieldIndex); return removedRecords().readDouble(getMappedOrdinal(ordinal), fieldIndex); }
return typeAccess.findVarLengthFieldHashCode(ordinal, fieldPosition); case DOUBLE: double d = typeAccess.readDouble(ordinal, fieldPosition); return doubleHashCode(d); case FLOAT: