public List<Field> getFields() { if(fields == null) fields = factory.createFields(this); return fields; }
public boolean isLeafNode() { return (from != null && from.getValue() != null) ? from.isLeafNode() : to == null ? true : to.isLeafNode(); } public boolean isDiff() {
public Field(String fieldName, HollowEffigy value) { this(fieldName, value.getObjectType(), value); }
private boolean rowIsExactMatch(HollowDiffViewRow row) { EffigyFieldPair fieldPair = row.getFieldPair(); if(fieldPair.getFrom() == null || fieldPair.getTo() == null || fieldPair.isLeafNode()) return false; HollowEffigy fromEffigy = (HollowEffigy)fieldPair.getFrom().getValue(); HollowEffigy toEffigy = (HollowEffigy)fieldPair.getTo().getValue(); if(fromEffigy == null || toEffigy == null) return false; return exactRecordMatcher.isExactMatch(fromEffigy.getDataAccess(), fromEffigy.getOrdinal(), toEffigy.getDataAccess(), toEffigy.getOrdinal()); }
public HollowDiffViewRow getHollowDiffViewRows() { HollowEffigy fromEffigy, toEffigy; if(diffUI != null && diffUI.getCustomHollowEffigyFactory(typeName) != null) { CustomHollowEffigyFactory effigyFactory = diffUI.getCustomHollowEffigyFactory(typeName); synchronized(effigyFactory) { effigyFactory.setFromHollowRecord(fromDataAccess.getTypeDataAccess(typeName), fromOrdinal); effigyFactory.setToHollowRecord(toDataAccess.getTypeDataAccess(typeName), toOrdinal); effigyFactory.generateEffigies(); fromEffigy = effigyFactory.getFromEffigy(); toEffigy = effigyFactory.getToEffigy(); } } else { HollowEffigyFactory effigyFactory = new HollowEffigyFactory(); fromEffigy = fromOrdinal == -1 ? null : effigyFactory.effigy(fromDataAccess, typeName, fromOrdinal); toEffigy = toOrdinal == -1 ? null : effigyFactory.effigy(toDataAccess, typeName, toOrdinal); } HollowDiffViewRow rootRow = createRootRow(fromEffigy, toEffigy); traverseEffigyToCreateViewRows(rootRow); return rootRow; }
private List<Field> createMapFields(HollowEffigy effigy) { List<Field> fields = new ArrayList<Field>(); HollowMapTypeDataAccess typeDataAccess = (HollowMapTypeDataAccess)effigy.dataAccess; HollowMapSchema schema = typeDataAccess.getSchema(); HollowMapEntryOrdinalIterator iter = typeDataAccess.ordinalIterator(effigy.ordinal); while(iter.next()) { HollowEffigy entryEffigy = new HollowEffigy("Map.Entry"); entryEffigy.add(new Field("key", effigy(typeDataAccess.getDataAccess(), schema.getKeyType(), iter.getKey()))); entryEffigy.add(new Field("value", effigy(typeDataAccess.getDataAccess(), schema.getValueType(), iter.getValue()))); fields.add(new Field("entry", "Map.Entry", entryEffigy)); } return fields; }
private void traverseOriginalFields(HollowEffigy effigy) { for(Field field : effigy.getFields()) { if(field.isLeafNode()) { FieldDiffCount fieldCount = map.get(field); if(fieldCount == null) { fieldCount = new FieldDiffCount(); map.put(field, fieldCount); } fieldCount.incrementOriginalCount(); totalOriginalFieldCount++; } else { traverseOriginalFields((HollowEffigy) field.getValue()); } } }
private void assertPair(EffigyFieldPair pair, String expectedFromField1, String expectedToField1) { if(expectedFromField1 != null) { HollowEffigy element = (HollowEffigy) pair.getFrom().getValue(); Assert.assertEquals(expectedFromField1, element.getFields().get(0).getValue()); } else { Assert.assertNull(pair.getFrom()); } if(expectedToField1 != null) { HollowEffigy element = (HollowEffigy) pair.getTo().getValue(); Assert.assertEquals(expectedToField1, element.getFields().get(0).getValue()); } else { Assert.assertNull(pair.getTo()); } }
private HollowEffigy list(HollowEffigy... elements) { HollowEffigy list = new HollowEffigy("list"); for(HollowEffigy element : elements) { list.add(new Field("element", element)); } return list; }
@Override public List<EffigyFieldPair> pair() { List<EffigyFieldPair> fieldPairs = new ArrayList<EffigyFieldPair>(); for(Field fromField : from.getFields()) { fieldPairs.add(new EffigyFieldPair(fromField, getField(to, fromField.getFieldName()), -1, -1)); } for(Field toField : to.getFields()) { Field fromField = getField(from, toField.getFieldName()); if(fromField == null) fieldPairs.add(new EffigyFieldPair(null, toField, -1, -1)); } return fieldPairs; }
private List<Field> createCollectionFields(HollowEffigy effigy) { List<Field> fields = new ArrayList<Field>(); HollowCollectionTypeDataAccess typeDataAccess = (HollowCollectionTypeDataAccess) effigy.dataAccess; HollowCollectionSchema schema = typeDataAccess.getSchema(); HollowOrdinalIterator iter = typeDataAccess.ordinalIterator(effigy.ordinal); int elementOrdinal = iter.next(); while(elementOrdinal != NO_MORE_ORDINALS) { HollowEffigy elementEffigy = effigy(typeDataAccess.getDataAccess(), schema.getElementType(), elementOrdinal); fields.add(new Field("element", elementEffigy)); elementOrdinal = iter.next(); } return fields; }
private static String fromContent(HollowDiffViewRow row) { boolean moreRows[] = new boolean[row.getIndentation() + 1]; for(int i=0;i<=row.getIndentation();i++) moreRows[i] = row.hasMoreFromRows(i); if(row.getFieldPair().getFrom() == null) return unpopulatedContent(moreRows); String fieldName = row.getFieldPair().getFrom().getFieldName(); return populatedContent(moreRows, row.getIndentation(), row.getFieldPair().isLeafNode(), fieldName, getFieldValue(row, true)); }
private static String toContent(HollowDiffViewRow row) { boolean moreRows[] = new boolean[row.getIndentation() + 1]; for(int i=0;i<=row.getIndentation();i++) moreRows[i] = row.hasMoreToRows(i); if(row.getFieldPair().getTo() == null) return unpopulatedContent(moreRows); String fieldName = row.getFieldPair().getTo().getFieldName(); return populatedContent(moreRows, row.getIndentation(), row.getFieldPair().isLeafNode(), fieldName, getFieldValue(row, false)); }
public Field getField(HollowEffigy effigy, String fieldName) { for(Field field : effigy.getFields()) { if(field.getFieldName().equals(fieldName)) return field; } return null; }
private boolean calculateIsDiff() { if((from == null && to != null) || (from != null && to == null)) return true; if(from.getValue() == null) return to.getValue() != null; if(isLeafNode()) return !from.getValue().equals(to.getValue()); return false; }
private HollowDiffViewRow createRootRow(HollowEffigy fromEffigy, HollowEffigy toEffigy) { HollowEffigy.Field fromField = fromEffigy == null ? null : new HollowEffigy.Field(null, fromEffigy); HollowEffigy.Field toField = toEffigy == null ? null : new HollowEffigy.Field(null, toEffigy); EffigyFieldPair fieldPair = new EffigyFieldPair(fromField, toField, -1, -1); return new HollowDiffViewRow(fieldPair, new int[0], null, this); }
private void addUnmatchedElements(List<EffigyFieldPair> fieldPairs, BitSet pairedFromIndices, BitSet pairedToIndices) { for(int i=0;i<from.getFields().size();i++) { if(!pairedFromIndices.get(i)) fieldPairs.add(new EffigyFieldPair(from.getFields().get(i), null, i, -1)); } for(int i=0;i<to.getFields().size();i++) { if(!pairedToIndices.get(i)) fieldPairs.add(new EffigyFieldPair(null, to.getFields().get(i), -1, i)); } }
List<Field> createFields(HollowEffigy effigy) { switch(effigy.dataAccess.getSchema().getSchemaType()) { case OBJECT: return createObjectFields(effigy); case LIST: case SET: return createCollectionFields(effigy); case MAP: return createMapFields(effigy); } throw new IllegalArgumentException(); }