@Override protected Integer getData(HollowObjectTypeReadState readState, int ordinal) { GenericHollowObject obj = new GenericHollowObject(new HollowObjectGenericDelegate(readState), ordinal); return obj.getInt("value"); }
private void appendFieldStringify(Writer writer, HollowDataAccess dataAccess, int indentation, HollowObjectSchema schema, GenericHollowObject obj, int i, String fieldName) throws IOException { if(obj.isNull(fieldName)) { writer.append("null"); } else { switch(schema.getFieldType(i)) { case BOOLEAN: writer.append(Boolean.toString(obj.getBoolean(fieldName))); break; case BYTES: writer.append(Arrays.toString(obj.getBytes(fieldName))); break; case DOUBLE: writer.append(Double.toString(obj.getDouble(fieldName))); break; case FLOAT: writer.append(Float.toString(obj.getFloat(fieldName))); break; case INT: writer.append(Integer.toString(obj.getInt(fieldName))); break; case LONG: writer.append(Long.toString(obj.getLong(fieldName))); break; case STRING: writer.append(obj.getString(fieldName)); break; case REFERENCE: int refOrdinal = obj.getOrdinal(fieldName); appendStringify(writer, dataAccess, schema.getReferencedType(i), refOrdinal, indentation);
private void assertTypeAWithTypeC(int ordinal, boolean a1, String a2, String c1) { HollowObjectTypeReadState typeAState = (HollowObjectTypeReadState)readStateEngine.getTypeState("TypeA"); GenericHollowObject typeAObj = new GenericHollowObject(new HollowObjectGenericDelegate(typeAState), ordinal); Assert.assertEquals(a1, typeAObj.getBoolean("a1")); Assert.assertEquals(a2, typeAObj.getString("a2")); GenericHollowObject typeCObj = (GenericHollowObject) typeAObj.getReferencedGenericRecord("a4"); Assert.assertEquals(c1, typeCObj.getString("c1")); }
public final HollowRecord getReferencedGenericRecord(String fieldName) { String referencedType = getSchema().getReferencedType(fieldName); if(referencedType == null) { try { HollowObjectSchema hollowObjectSchema = (HollowObjectSchema)getTypeDataAccess().getDataAccess().getMissingDataHandler().handleSchema(getSchema().getName()); referencedType = hollowObjectSchema.getReferencedType(fieldName); if(referencedType == null) return null; } catch(Exception e) { return null; } } int ordinal = getOrdinal(fieldName); if(ordinal == -1) return null; return GenericHollowRecordHelper.instantiate(getTypeDataAccess().getDataAccess(), referencedType, ordinal); }
@Override protected Float getData(HollowObjectTypeReadState readState, int ordinal) { GenericHollowObject obj = new GenericHollowObject(new HollowObjectGenericDelegate(readState), ordinal); return obj.getFloat("value"); }
GenericHollowObject obj = new GenericHollowObject(readEngine, "TestTopLevelObject", 0); GenericHollowObject element = (GenericHollowObject) obj.getSet("setById").findElement(1); Assert.assertEquals("US", element.getObject("country").getString("value")); element = (GenericHollowObject) obj.getSet("setById").findElement(2); Assert.assertEquals("CA", element.getObject("country").getString("value")); element = (GenericHollowObject) obj.getSet("setById").findElement(3); Assert.assertEquals("IT", element.getObject("country").getString("value")); element = (GenericHollowObject) obj.getSet("setById").findElement(4); Assert.assertEquals("GB", element.getObject("country").getString("value")); element = (GenericHollowObject) obj.getSet("setById").findElement(5); Assert.assertEquals("IT", element.getObject("country").getString("value")); element = (GenericHollowObject)obj.getSet("setByIdCountry").findElement(1, "US"); Assert.assertEquals(1, element.getInt("id")); element = (GenericHollowObject)obj.getSet("setByIdCountry").findElement(2, "CA"); Assert.assertEquals(2, element.getInt("id")); element = (GenericHollowObject)obj.getSet("setByIdCountry").findElement(3, "IT"); Assert.assertEquals(3, element.getInt("id")); element = (GenericHollowObject)obj.getSet("setByIdCountry").findElement(4, "GB"); Assert.assertEquals(4, element.getInt("id")); element = (GenericHollowObject)obj.getSet("setByIdCountry").findElement(5, "IT"); Assert.assertEquals(5, element.getInt("id")); element = (GenericHollowObject)obj.getSet("intSet").findElement(100); Assert.assertEquals(100, element.getInt("value")); element = (GenericHollowObject)obj.getSet("intSet").findElement(200); Assert.assertEquals(200, element.getInt("value")); element = (GenericHollowObject)obj.getSet("intSet").findElement(300);
private void assertObject(HollowObjectTypeReadState readState, int ordinal, int intVal, String strVal) { GenericHollowObject obj = new GenericHollowObject(new HollowObjectGenericDelegate(readState), ordinal); Assert.assertEquals(intVal, obj.getInt("f1")); Assert.assertEquals(strVal, obj.getString("f2")); }
consumer.triggerRefresh(); GenericHollowObject typeA0 = new GenericHollowObject(consumer.getStateEngine(), "TypeA", 0); GenericHollowObject typeA1 = new GenericHollowObject(consumer.getStateEngine(), "TypeA", 1); Assert.assertEquals(1, typeA0.getInt("a1")); Assert.assertEquals("two", typeA0.getString("a2")); Assert.assertEquals("three", typeA0.getObject("a3").getString("b1")); Assert.assertNull(typeA0.getSet("a4")); Assert.assertNull(typeA0.getBytes("a5")); Assert.assertEquals(2, typeA1.getInt("a1")); Assert.assertEquals("two", typeA1.getString("a2")); Assert.assertEquals("four", typeA1.getObject("a3").getString("b1")); Assert.assertNull(typeA1.getSet("a4")); Assert.assertNull(typeA1.getBytes("a4")); GenericHollowObject typeC0 = new GenericHollowObject(consumer.getStateEngine(), "TypeC", 0); Assert.assertTrue(typeC0.isNull("c1")); Assert.assertEquals("three", typeC0.getObject("c2").getString("b1")); Assert.assertTrue(typeC0.isNull("c3")); Assert.assertEquals(typeC0.getObject("c2").getOrdinal(), typeA0.getObject("a3").getOrdinal());
private void assertObject(int ordinal, long l, int i, double d) { HollowObjectTypeReadState typeState = (HollowObjectTypeReadState) readStateEngine.getTypeState("TestObject"); GenericHollowObject obj = new GenericHollowObject(new HollowObjectGenericDelegate(typeState), ordinal); Assert.assertEquals(l, obj.getLong("longField")); Assert.assertEquals(i, obj.getInt("intField")); Assert.assertTrue(d == obj.getDouble("doubleField")); }
@Override protected Long getData(HollowObjectTypeReadState readState, int ordinal) { GenericHollowObject obj = new GenericHollowObject(new HollowObjectGenericDelegate(readState), ordinal); return obj.getLong("value"); }
private void assertTypeA(int ordinal, int a1, int bOrdinal) { HollowObjectTypeReadState typeState = (HollowObjectTypeReadState) readStateEngine.getTypeState("TypeA"); GenericHollowObject obj = new GenericHollowObject(new HollowObjectGenericDelegate(typeState), ordinal); Assert.assertEquals(a1, obj.getInt("a1")); Assert.assertEquals(bOrdinal, obj.getOrdinal("a2")); }
@Test public void testBuild_withTypeInitialization() { HollowReadStateEngine readEngine = new HollowReadStateEngineBuilder(Arrays.<Class<?>>asList(String.class, Long.class)) .add("foo").add(3L).build(); assertEquals("Should have both types", new HashSet<String>(Arrays.asList( String.class.getSimpleName(), Long.class.getSimpleName())), new HashSet<String>(readEngine.getAllTypes())); assertEquals("Should have one String", 1, readEngine.getTypeDataAccess( String.class.getSimpleName()).getTypeState().getPopulatedOrdinals().cardinality()); assertEquals("The one String should be foo", "foo", new GenericHollowObject(readEngine, String.class.getSimpleName(), 0).getString("value")); assertEquals("Should have one Long", 1, readEngine.getTypeDataAccess( Long.class.getSimpleName()).getTypeState().getPopulatedOrdinals().cardinality()); assertEquals("The one Long should be 3L", 3L, new GenericHollowObject(readEngine, Long.class.getSimpleName(), 0).getLong("value")); }
@Override protected HollowObject getForOrdinal(int ordinal) { return new GenericHollowObject(readStateEngine, type, ordinal); } };
private void assertA(HollowReadStateEngine stateEngine, int id, String val, boolean verifyEchoes) { HollowPrimaryKeyIndex idx = new HollowPrimaryKeyIndex(stateEngine, "TypeA", "id"); int ordinal = idx.getMatchingOrdinal(id); GenericHollowObject a = (GenericHollowObject) GenericHollowRecordHelper.instantiate(stateEngine, "TypeA", ordinal); GenericHollowList bList = (GenericHollowList)a.getReferencedGenericRecord("b"); GenericHollowObject b = (GenericHollowObject)bList.get(0); GenericHollowObject str = (GenericHollowObject)b.getReferencedGenericRecord("val"); Assert.assertEquals(val, str.getString("value")); if(verifyEchoes) { Assert.assertEquals(id, a.getInt("idEcho")); Assert.assertEquals(id, b.getInt("idEcho")); } }
private void assertTypeA(int ordinal, boolean a1, String a2) { HollowObjectTypeReadState typeState = (HollowObjectTypeReadState)readStateEngine.getTypeState("TypeA"); GenericHollowObject obj = new GenericHollowObject(new HollowObjectGenericDelegate(typeState), ordinal); Assert.assertEquals(a1, obj.getBoolean("a1")); Assert.assertEquals(a2, obj.getString("a2")); }
private void assertTypeB(int ordinal, int b1, boolean b2) { HollowObjectTypeReadState typeState = (HollowObjectTypeReadState) readStateEngine.getTypeState("TypeB"); GenericHollowObject obj = new GenericHollowObject(new HollowObjectGenericDelegate(typeState), ordinal); Assert.assertEquals(b1, obj.getInt("b1")); Assert.assertEquals(b2, obj.getBoolean("b2")); }
Assert.assertEquals(1, new GenericHollowObject(readEngine, "TypeA", 0).getInt("id")); Assert.assertEquals(2, new GenericHollowObject(readEngine, "TypeA", 1).getInt("id")); Assert.assertEquals(3, new GenericHollowObject(readEngine, "TypeA", 3).getInt("id")); Assert.assertEquals(1, new GenericHollowObject(readEngine, "TypeB", 0).getInt("id")); Assert.assertEquals(1.1f, new GenericHollowObject(readEngine, "TypeB", 0).getFloat("value"), 0); Assert.assertEquals(2, new GenericHollowObject(readEngine, "TypeB", 1).getInt("id")); Assert.assertEquals(2.2f, new GenericHollowObject(readEngine, "TypeB", 1).getFloat("value"), 0); Assert.assertEquals(3, new GenericHollowObject(readEngine, "TypeB", 3).getInt("id")); Assert.assertEquals(4.4f, new GenericHollowObject(readEngine, "TypeB", 3).getFloat("value"), 0);
private void assertTypeB(HollowPrimaryKeyIndex typeBIdx, int id1, String expectedValue) { int ordinal = typeBIdx.getMatchingOrdinal(id1); if (expectedValue == null) { Assert.assertEquals(-1, ordinal); } else { Assert.assertNotEquals(-1, ordinal); GenericHollowObject obj = new GenericHollowObject( typeBIdx.getTypeState(), ordinal); Assert.assertEquals(expectedValue, obj.getObject("value") .getString("value")); } }
@Override protected String getData(HollowObjectTypeReadState readState, int ordinal) { GenericHollowObject obj = new GenericHollowObject(new HollowObjectGenericDelegate(readState), ordinal); return obj.getString("value"); }
private void assertUpdatedList(Collection<UpdatedRecord<GenericHollowObject>> listOfObj, List<String> beforeValues, List<String> afterValues) { int i = 0; for (UpdatedRecord<GenericHollowObject> obj : listOfObj) { int beforeId = obj.getBefore().getInt("f1"); int afterId = obj.getAfter().getInt("f1"); Assert.assertEquals(beforeId, afterId); String beforeVal = beforeValues.get(i); String afterVal = afterValues.get(i++); Assert.assertNotEquals(beforeVal, afterVal); Assert.assertEquals(beforeVal, obj.getBefore().getString("f2")); Assert.assertEquals(afterVal, obj.getAfter().getString("f2")); } }