@Override public int readInt(int ordinal, int fieldIndex) { return ((HollowObjectTypeDataAccess) currentDataAccess).readInt(ordinal, fieldIndex); }
public int getValue(int ordinal) { if(fieldIndex[0] == -1) return missingDataHandler().handleInt("Integer", ordinal, "value"); return getTypeDataAccess().readInt(ordinal, fieldIndex[0]); }
public Integer getValueBoxed(int ordinal) { int i; if(fieldIndex[0] == -1) { i = missingDataHandler().handleInt("Integer", ordinal, "value"); } else { boxedFieldAccessSampler.recordFieldAccess(fieldIndex[0]); i = getTypeDataAccess().readInt(ordinal, fieldIndex[0]); } if(i == Integer.MIN_VALUE) return null; return Integer.valueOf(i); }
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)); }
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; } }
return Float.isNaN(f) ? null : Float.valueOf(f); case INT: int i = typeAccess.readInt(ordinal, fieldPosition); if(i == Integer.MIN_VALUE) return null;
return dataAccess.readFloat(ordinal, lastFieldIdx) == ((Float)key).floatValue(); case INT: return dataAccess.readInt(ordinal, lastFieldIdx) == ((Integer)key).intValue(); case LONG: return dataAccess.readLong(ordinal, lastFieldIdx) == ((Long)key).longValue();
@Override public boolean shouldIndex(int ordinal) { HollowObjectTypeDataAccess objectTypeDataAccess = (HollowObjectTypeDataAccess) readStateEngine.getTypeDataAccess("Movie"); int yearReleasedFieldPosition = objectTypeDataAccess.getSchema().getPosition("releaseYear"); int yearReleased = objectTypeDataAccess.readInt(ordinal, yearReleasedFieldPosition); if (yearReleased == 2009) return true; return false; } };
break; case INT: values.add(objectAccess.readInt(ordinals.get(i), fieldIdx)); break; case LONG:
@Override public int getInt(int ordinal, String fieldName) { HollowObjectTypeDataAccess dataAccess = getTypeDataAccess(); int fieldIndex = getSchema().getPosition(fieldName); if(fieldIndex == -1) return missingDataHandler().handleInt(getSchema().getName(), ordinal, fieldName); return dataAccess.readInt(ordinal, fieldIndex); }
break; case INT: fieldValue = Integer.valueOf(typeDataAccess.readInt(effigy.ordinal, i)); break; case LONG:
@Override public int readInt(int ordinal, int fieldIndex) { sampler().recordFieldAccess(fieldIndex); recordStackTrace(); if(!ordinalIsPresent(ordinal)) return ((HollowObjectTypeDataAccess)dataAccess.getTypeDataAccess(getSchema().getName(), ordinal)).readInt(ordinal, fieldIndex); return removedRecords().readInt(getMappedOrdinal(ordinal), fieldIndex); }
return floatHashCode(f); case INT: return intHashCode(typeAccess.readInt(ordinal, fieldPosition)); case LONG: long l = typeAccess.readLong(ordinal, fieldPosition);
@Test public void testClientAPIHoldsLongLivedReferences() throws IOException { client.triggerRefreshTo(1); HollowAPI api = client.getAPI(); HollowObjectTypeDataAccess dataAccess = (HollowObjectTypeDataAccess) api.getDataAccess().getTypeDataAccess("TestObject"); client.triggerRefreshTo(2); client.triggerRefreshTo(3); client.triggerRefreshTo(4); Assert.assertEquals(1, dataAccess.readInt(1, 0)); Assert.assertEquals("one", dataAccess.readString(1, 1)); Assert.assertEquals(3, dataAccess.readInt(3, 0)); Assert.assertEquals("three", dataAccess.readString(3, 1)); }