@Override public String readString(int ordinal, int fieldIndex) { return ((HollowObjectTypeDataAccess) currentDataAccess).readString(ordinal, fieldIndex); }
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; } }
public String getValue(int ordinal) { if(fieldIndex[0] == -1) return missingDataHandler().handleString("String", ordinal, "value"); boxedFieldAccessSampler.recordFieldAccess(fieldIndex[0]); return getTypeDataAccess().readString(ordinal, fieldIndex[0]); }
/** * @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.readBytes(ordinal, fieldPosition); case STRING: return typeAccess.readString(ordinal, fieldPosition); case DOUBLE: double d = typeAccess.readDouble(ordinal, 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; } }
case STRING: if(testObject instanceof String) return testObject.equals(typeAccess.readString(ordinal, fieldPosition)); return testObject == null && typeAccess.readString(ordinal, fieldPosition) == null; case DOUBLE: if(testObject instanceof Double)
break; case STRING: values.add(objectAccess.readString(ordinals.get(i), fieldIdx)); break; case REFERENCE:
@Override public String getString(int ordinal, String fieldName) { HollowObjectTypeDataAccess dataAccess = getTypeDataAccess(); int fieldIndex = getSchema().getPosition(fieldName); if(fieldIndex == -1) return missingDataHandler().handleString(getSchema().getName(), ordinal, fieldName); return dataAccess.readString(ordinal, fieldIndex); }
break; case STRING: fieldValue = typeDataAccess.readString(effigy.ordinal, i); break; case REFERENCE:
@Override public String readString(int ordinal, int fieldIndex) { sampler().recordFieldAccess(fieldIndex); recordStackTrace(); if(!ordinalIsPresent(ordinal)) return ((HollowObjectTypeDataAccess)dataAccess.getTypeDataAccess(getSchema().getName(), ordinal)).readString(ordinal, fieldIndex); return removedRecords().readString(getMappedOrdinal(ordinal), fieldIndex); }
return l1 == l2; case STRING: String s1 = typeAccess1.readString(ordinal1, fieldPosition1); return typeAccess2.isStringFieldEqual(ordinal2, fieldPosition2, s1); case REFERENCE:
private String roundTripInlinedStringValue(String value) throws IOException { HollowObjectMapper mapper = new HollowObjectMapper(writeStateEngine); mapper.add(new TypeD(value)); roundTripSnapshot(); HollowObjectTypeDataAccess typeDataAccess = (HollowObjectTypeDataAccess) readStateEngine.getTypeDataAccess("TypeD"); int stringFieldIndex = typeDataAccess.getSchema().getPosition("inlinedString"); return typeDataAccess.readString(0, stringFieldIndex); }
@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)); }
private String roundTripReferenceStringValue(String value) throws IOException { HollowObjectMapper mapper = new HollowObjectMapper(writeStateEngine); mapper.add(new TypeA(value, 1, null, null)); roundTripSnapshot(); HollowObjectTypeDataAccess typeDataAccess = (HollowObjectTypeDataAccess) readStateEngine.getTypeDataAccess("TypeA"); int stringFieldIndex = typeDataAccess.getSchema().getPosition("a1"); int stringValueOrdinal = typeDataAccess.readOrdinal(0, stringFieldIndex); HollowObjectTypeDataAccess stringDataAccess = (HollowObjectTypeDataAccess) readStateEngine.getTypeDataAccess("String"); int stringValueField = stringDataAccess.getSchema().getPosition("value"); return stringDataAccess.readString(stringValueOrdinal, stringValueField); }