@Override public int readOrdinal(int ordinal, int fieldIndex) { return ((HollowObjectTypeDataAccess) currentDataAccess).readOrdinal(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; } }
for(int i=0;i<lastFieldPath;i++) { int fieldPosition = fieldPathIndexes[fieldIdx][i]; ordinal = dataAccess.readOrdinal(ordinal, fieldPosition); dataAccess = (HollowObjectTypeDataAccess) dataAccess.getDataAccess().getTypeDataAccess(schema.getReferencedType(fieldPosition), ordinal); schema = dataAccess.getSchema(); return dataAccess.readLong(ordinal, lastFieldIdx) == ((Long)key).longValue(); case REFERENCE: return dataAccess.readOrdinal(ordinal, lastFieldIdx) == ((Integer)key).intValue(); case STRING: return dataAccess.isStringFieldEqual(ordinal, lastFieldIdx, (String)key);
case REFERENCE: if(testObject instanceof Integer) return testObject.equals(typeAccess.readOrdinal(ordinal, fieldPosition)); return testObject == null && typeAccess.readOrdinal(ordinal, fieldPosition) < 0; default:
return Long.valueOf(l); case REFERENCE: int refOrdinal = typeAccess.readOrdinal(ordinal, fieldPosition); if(refOrdinal < 0) return null;
@Override public int doTraversal(int ordinal) { prepareMultiply(); for(int i=0;i<children.length;i++) { if(children[i] instanceof HollowIndexerObjectFieldTraversalNode) { children[i].traverse(ordinal); } else { int childOrdinal = dataAccess().readOrdinal(ordinal, childOrdinalFieldPositions[i]); if(childOrdinal != -1) children[i].traverse(childOrdinal); } } return doMultiply(); }
@Override public int getOrdinal(int ordinal, String fieldName) { HollowObjectTypeDataAccess dataAccess = getTypeDataAccess(); int fieldIndex = getSchema().getPosition(fieldName); if(fieldIndex == -1) return missingDataHandler().handleReferencedOrdinal(getSchema().getName(), ordinal, fieldName); return dataAccess.readOrdinal(ordinal, fieldIndex); }
case REFERENCE: if(typeAccess1 == typeAccess2 && fieldPosition1 == fieldPosition2) return typeAccess1.readOrdinal(ordinal1, fieldPosition1) == typeAccess2.readOrdinal(ordinal2, fieldPosition2); default:
private int fieldHashCode(HollowEffigy element, int[] fieldPath) { HollowObjectTypeDataAccess dataAccess = (HollowObjectTypeDataAccess) element.getDataAccess(); HollowObjectSchema schema = dataAccess.getSchema(); int ordinal = element.getOrdinal(); for (int i = 0; i < fieldPath.length - 1; i++) { int fieldPosition = fieldPath[i]; ordinal = dataAccess.readOrdinal(ordinal, fieldPosition); dataAccess = (HollowObjectTypeDataAccess) dataAccess.getDataAccess().getTypeDataAccess(schema.getReferencedType(fieldPosition)); schema = dataAccess.getSchema(); } int fieldHash = HollowReadFieldUtils.fieldHashCode(dataAccess, ordinal, fieldPath[fieldPath.length-1]); return HashCodes.hashInt(fieldHash); }
break; case REFERENCE: fieldValue = effigy(typeDataAccess.getDataAccess(), schema.getReferencedType(i), typeDataAccess.readOrdinal(effigy.ordinal, i));
int refOrdinal = objectTypeDataAccess.readOrdinal(ordinal, fieldPositions[fieldIndex]); if (refOrdinal >= 0) { String refType = objectSchema.getReferencedType(fieldPositions[fieldIndex]);
private boolean fieldsAreEqual(HollowEffigy fromElement, HollowEffigy toElement, int[] fromFieldPath, int[] toFieldPath) { HollowObjectTypeDataAccess fromDataAccess = (HollowObjectTypeDataAccess) fromElement.getDataAccess(); int fromOrdinal = fromElement.getOrdinal(); HollowObjectTypeDataAccess toDataAccess = (HollowObjectTypeDataAccess) toElement.getDataAccess(); int toOrdinal = toElement.getOrdinal(); HollowObjectSchema fromSchema = fromDataAccess.getSchema(); HollowObjectSchema toSchema = toDataAccess.getSchema(); for (int i = 0; i < fromFieldPath.length - 1; i++) { int fromFieldPosition = fromFieldPath[i]; int toFieldPosition = toFieldPath[i]; fromOrdinal = fromDataAccess.readOrdinal(fromOrdinal, fromFieldPosition); toOrdinal = toDataAccess.readOrdinal(toOrdinal, toFieldPosition); fromDataAccess = (HollowObjectTypeDataAccess) fromDataAccess.getDataAccess().getTypeDataAccess(fromSchema.getReferencedType(fromFieldPosition)); toDataAccess = (HollowObjectTypeDataAccess) toDataAccess.getDataAccess().getTypeDataAccess(toSchema.getReferencedType(toFieldPosition)); fromSchema = fromDataAccess.getSchema(); toSchema = toDataAccess.getSchema(); } return HollowReadFieldUtils.fieldsAreEqual(fromDataAccess, fromOrdinal, fromFieldPath[fromFieldPath.length-1], toDataAccess, toOrdinal, toFieldPath[toFieldPath.length-1]); }
@Override public int readOrdinal(int ordinal, int fieldIndex) { sampler().recordFieldAccess(fieldIndex); recordStackTrace(); if(!ordinalIsPresent(ordinal)) return ((HollowObjectTypeDataAccess)dataAccess.getTypeDataAccess(getSchema().getName(), ordinal)).readOrdinal(ordinal, fieldIndex); return removedRecords().readOrdinal(getMappedOrdinal(ordinal), fieldIndex); }
return longHashCode(l); case REFERENCE: return typeAccess.readOrdinal(ordinal, fieldPosition);
childDataAccess = typeDataAccess.getDataAccess().getTypeDataAccess(objectAccess.getSchema().getReferencedType(fieldIdx)); for(int i=0;i<ordinals.size();i++) childOrdinals.add(objectAccess.readOrdinal(ordinals.get(i), fieldIdx)); } else if(typeDataAccess instanceof HollowCollectionTypeDataAccess) { HollowCollectionTypeDataAccess collectionAccess = (HollowCollectionTypeDataAccess)typeDataAccess;
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); }
int refOrdinal = objectTypeDataAccess.readOrdinal(ordinal, fieldPositions[fieldIndex]); if (refOrdinal >= 0) { String refType = objectSchema.getReferencedType(fieldPositions[fieldIndex]);