@Override public float readFloat(int ordinal, int fieldIndex) { return ((HollowObjectTypeDataAccess) currentDataAccess).readFloat(ordinal, fieldIndex); }
public Float getValueBoxed(int ordinal) { float f; if(fieldIndex[0] == -1) { f = missingDataHandler().handleFloat("Float", ordinal, "value"); } else { boxedFieldAccessSampler.recordFieldAccess(fieldIndex[0]); f = getTypeDataAccess().readFloat(ordinal, fieldIndex[0]); } return Float.isNaN(f) ? null : Float.valueOf(f); }
public float getValue(int ordinal) { if(fieldIndex[0] == -1) return missingDataHandler().handleFloat("Float", ordinal, "value"); return getTypeDataAccess().readFloat(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 Double.isNaN(d) ? null : Double.valueOf(d); case FLOAT: float f = typeAccess.readFloat(ordinal, fieldPosition); return Float.isNaN(f) ? null : Float.valueOf(f); case INT:
return dataAccess.readDouble(ordinal, lastFieldIdx) == ((Double)key).doubleValue(); case FLOAT: return dataAccess.readFloat(ordinal, lastFieldIdx) == ((Float)key).floatValue(); case INT: return dataAccess.readInt(ordinal, lastFieldIdx) == ((Integer)key).intValue();
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; } }
break; case FLOAT: values.add(objectAccess.readFloat(ordinals.get(i), fieldIdx)); break; case INT:
@Override public float getFloat(int ordinal, String fieldName) { HollowObjectTypeDataAccess dataAccess = getTypeDataAccess(); int fieldIndex = getSchema().getPosition(fieldName); if(fieldIndex == -1) return missingDataHandler().handleFloat(getSchema().getName(), ordinal, fieldName); return dataAccess.readFloat(ordinal, fieldIndex); }
break; case FLOAT: fieldValue = Float.valueOf(typeDataAccess.readFloat(effigy.ordinal, i)); break; case INT:
@Override public float readFloat(int ordinal, int fieldIndex) { sampler().recordFieldAccess(fieldIndex); recordStackTrace(); if(!ordinalIsPresent(ordinal)) return ((HollowObjectTypeDataAccess)dataAccess.getTypeDataAccess(getSchema().getName(), ordinal)).readFloat(ordinal, fieldIndex); return removedRecords().readFloat(getMappedOrdinal(ordinal), fieldIndex); }
return doubleHashCode(d); case FLOAT: float f = typeAccess.readFloat(ordinal, fieldPosition); return floatHashCode(f); case INT: