@Override public void reset() { elementOrdinals.clear(); }
public void reset() { buf.reset(); recordLocationsByHashCode.clear(); recordLocationsByOrdinal.clear(); }
private IntList toIntList(int ordinal) { toIntList.clear(); toIntList.add(ordinal); return toIntList; } });
private IntList getIntList() { IntList list = intList.get(); if(list == null) { list = new IntList(); intList.set(list); } list.clear(); return list; }
private IntList fromIntList(int ordinal) { fromIntList.clear(); fromIntList.add(ordinal); return fromIntList; }
public void traverse(int ordinal) { for(int i=0;i<fieldMatchLists.length;i++) fieldMatchLists[i].clear(); rootNode.traverse(ordinal); }
private void fillTraversalLists(IntList fromOrdinals, IntList toOrdinals) { traversalFromKeyOrdinals.clear(); traversalToKeyOrdinals.clear(); traversalFromValueOrdinals.clear(); traversalToValueOrdinals.clear(); if(fromState != null) { for(int i=0;i<fromOrdinals.size();i++) { fillListsWithReferencedOrdinals(fromState, fromOrdinals.get(i), traversalFromKeyOrdinals, traversalFromValueOrdinals); } } if(toState != null) { for(int i=0;i<toOrdinals.size();i++) { fillListsWithReferencedOrdinals(toState, toOrdinals.get(i), traversalToKeyOrdinals, traversalToValueOrdinals); } } }
private void fillTraversalLists(IntList fromOrdinals, IntList toOrdinals) { traversalFromOrdinals.clear(); traversalToOrdinals.clear(); if(fromState != null) { for(int i=0;i<fromOrdinals.size();i++) { fillListWithReferencedOrdinals(fromState, fromOrdinals.get(i), traversalFromOrdinals); } } if(toState != null) { for(int i=0;i<toOrdinals.size();i++) { fillListWithReferencedOrdinals(toState, toOrdinals.get(i), traversalToOrdinals); } } }
private boolean populateIntList(IntList list, HollowOrdinalIterator iter, OrdinalIdentityTranslator identityTranslator) { list.clear(); int nextOrdinal = iter.next(); while(nextOrdinal != HollowOrdinalIterator.NO_MORE_ORDINALS) { int identityOrdinal = identityTranslator.getIdentityOrdinal(nextOrdinal); if(identityOrdinal == -1 && nextOrdinal != -1) return false; list.add(identityOrdinal); nextOrdinal = iter.next(); } if(!orderingIsImportant) list.sort(); return true; } };
public int traverseMissingFields(IntList fromOrdinals, IntList toOrdinals) { int score = 0; for(int i=0;i<fieldNodes.length;i++) { if(fieldRequiresMissingFieldTraversal[i]) { traversalFromOrdinals.clear(); traversalToOrdinals.clear(); if(fromFieldMapping[i] != -1) { for(int j=0;j<fromOrdinals.size();j++) { int fromOrdinal = fromState.readOrdinal(fromOrdinals.get(j), fromFieldMapping[i]); if(fromOrdinal != -1) traversalFromOrdinals.add(fromOrdinal); } } if(toFieldMapping[i] != -1) { for(int j=0;j<toOrdinals.size();j++) { int toOrdinal = toState.readOrdinal(toOrdinals.get(j), toFieldMapping[i]); if(toOrdinal != -1) traversalToOrdinals.add(toOrdinal); } } score += fieldNodes[i].traverseMissingFields(traversalFromOrdinals, traversalToOrdinals); } else if(fieldNodes[i] instanceof HollowDiffFieldCountingNode) { score += fieldNodes[i].traverseMissingFields(fromOrdinals, toOrdinals); } } return score; }
public boolean next() { list.clear(); while(currentShardList < shardedResults.length) { if(currentShardListPosition < shardedResults[currentShardList].size()) { currentFromOrdinal = (int)(shardedResults[currentShardList].get(currentShardListPosition) >> 32); while(currentShardListPosition < shardedResults[currentShardList].size() && (int)(shardedResults[currentShardList].get(currentShardListPosition) >> 32) == currentFromOrdinal) { int toOrdinal = (int)shardedResults[currentShardList].get(currentShardListPosition); list.add(toOrdinal); currentShardListPosition++; } return true; } currentShardListPosition = 0; currentShardList++; } return false; }
public boolean recordsAreEqual(int ordinal) { int size = fromSetState.size(ordinal); if(toSetState.size(ordinal) != size) return false; fromScratch.clear(); toScratch.clear(); HollowOrdinalIterator iter = fromSetState.ordinalIterator(ordinal); int next = iter.next(); while(next != HollowOrdinalIterator.NO_MORE_ORDINALS) { fromScratch.add(next); next = iter.next(); } iter = toSetState.ordinalIterator(ordinal); next = iter.next(); while(next != HollowOrdinalIterator.NO_MORE_ORDINALS) { toScratch.add(next); next = iter.next(); } fromScratch.sort(); toScratch.sort(); return fromScratch.equals(toScratch); } };
private boolean populateIntLists(IntList keysList, IntList valuesList, HollowMapEntryOrdinalIterator iter, OrdinalIdentityTranslator keyTranslator, OrdinalIdentityTranslator valueTranslator) { keysList.clear(); valuesList.clear(); while(iter.next()) { int keyIdentity = keyTranslator.getIdentityOrdinal(iter.getKey()); int valueIdentity = valueTranslator.getIdentityOrdinal(iter.getValue()); if(keyIdentity == -1 && iter.getKey() != -1) return false; if(valueIdentity == -1 && iter.getValue() != -1) return false; keysList.add(keyTranslator.getIdentityOrdinal(iter.getKey())); valuesList.add(valueTranslator.getIdentityOrdinal(iter.getValue())); } keysList.sort(); valuesList.sort(); return true; } };