public void addElement(int ordinal) { elementOrdinals.add(ordinal); }
JsonArrayChunkerInputSegment findSpecialCharacterOffsets() { for (int i = 0; i < data.length; i++) { switch (data[i]) { case '{': specialCharacterOffsets.add(i); break; case '}': specialCharacterOffsets.add(i | (1 << 30)); break; case '\"': specialCharacterOffsets.add(i | (2 << 30)); break; case '\\': specialCharacterOffsets.add(i | (3 << 30)); break; default: } } return this; }
private IntList fromIntList(int ordinal) { fromIntList.clear(); fromIntList.add(ordinal); return fromIntList; }
private IntList toIntList(int ordinal) { toIntList.clear(); toIntList.add(ordinal); return toIntList; } });
public void traverse(int ordinal) { if(childFirstFieldMap.length == 0) { doTraversal(ordinal); if(indexedFieldPosition != -1) fieldMatches[indexedFieldPosition].add(ordinal); } else { int childMatchSize = doTraversal(ordinal); if(indexedFieldPosition != -1) { for(int i=0;i<childMatchSize;i++) fieldMatches[indexedFieldPosition].add(ordinal); } } }
public void addAll(IntList list) { for(int i=0;i<list.size;i++) add(list.get(i)); }
/** * Should be called exclusively from the {@link HollowDiff} -- not intended for external consumption * * @param fromOrdinal the from ordinal * @param toOrdinal the to ordinal * @param score the score */ public void addDiff(int fromOrdinal, int toOrdinal, int score) { if(isSameDiffAsLastAdd(fromOrdinal, toOrdinal)) { int scoreIdx = diffPairScores.size() - 1; diffPairScores.set(scoreIdx, diffPairScores.get(scoreIdx) + score); } else { diffFromOrdinals.add(fromOrdinal); diffToOrdinals.add(toOrdinal); diffPairScores.add(score); } totalDiffScore += score; }
private void fillListsWithReferencedOrdinals(HollowMapTypeReadState typeState, int ordinal, IntList fillKeyList, IntList fillValueList) { HollowMapEntryOrdinalIterator iter = typeState.ordinalIterator(ordinal); while(iter.next()) { fillKeyList.add(iter.getKey()); fillValueList.add(iter.getValue()); } }
private void fillListWithReferencedOrdinals(HollowCollectionTypeReadState typeState, int ordinal, IntList fillList) { HollowOrdinalIterator iter = typeState.ordinalIterator(ordinal); int refOrdinal = iter.next(); while(refOrdinal != HollowOrdinalIterator.NO_MORE_ORDINALS) { fillList.add(refOrdinal); refOrdinal = iter.next(); } }
private IntList list(int... values) { IntList list = new IntList(values.length); for(int i=0;i<values.length;i++) { list.add(values[i]); } return list; }
/** * @return the transitive child branch field positions */ public IntList setUpMultiplication() { this.shouldMultiplyBranchResults = shouldMultiplyBranchResults(); this.childrenRepeatCounts = new int[children.size()]; this.childrenMatchCounts = new int[children.size()]; this.fieldChildMap = new int[fieldMatches.length]; this.childFirstFieldMap = new int[children.size()]; Arrays.fill(fieldChildMap, -1); IntList branchFieldPositions = new IntList(); if(indexedFieldPosition != -1) branchFieldPositions.add(indexedFieldPosition); int childCounter = 0; for(Map.Entry<String, HollowIndexerTraversalNode> entry : children.entrySet()) { IntList childBranchFieldPositions = entry.getValue().setUpMultiplication(); this.childFirstFieldMap[childCounter] = childBranchFieldPositions.get(0); for(int i=0;i<childBranchFieldPositions.size();i++) { this.fieldChildMap[childBranchFieldPositions.get(i)] = childCounter; branchFieldPositions.add(childBranchFieldPositions.get(i)); } childCounter++; } return branchFieldPositions; }
private IntList list(int... ordinals) { IntList list = new IntList(ordinals.length); for(int i=0;i<ordinals.length;i++) { list.add(ordinals[i]); } return list; }
public void calculateMatches() { fromIdx = new HollowPrimaryKeyIndex(fromTypeState.getStateEngine(), fromTypeState.getSchema().getName(), matchPaths.toArray(new String[matchPaths.size()])); toIdx = new HollowPrimaryKeyIndex(toTypeState.getStateEngine(), toTypeState.getSchema().getName(), matchPaths.toArray(new String[matchPaths.size()])); BitSet fromPopulatedOrdinals = fromTypeState.getListener(PopulatedOrdinalListener.class).getPopulatedOrdinals(); BitSet fromUnmatchedOrdinals = new BitSet(fromPopulatedOrdinals.length()); fromUnmatchedOrdinals.or(fromPopulatedOrdinals); BitSet toPopulatedOrdinals = toTypeState.getListener(PopulatedOrdinalListener.class).getPopulatedOrdinals(); int candidateToMatchOrdinal = toPopulatedOrdinals.nextSetBit(0); while(candidateToMatchOrdinal != -1) { Object key[] = toIdx.getRecordKey(candidateToMatchOrdinal); int matchedOrdinal = fromIdx.getMatchingOrdinal(key); if(matchedOrdinal != -1) { matchedOrdinals.add(((long)matchedOrdinal << 32) | candidateToMatchOrdinal); fromUnmatchedOrdinals.clear(matchedOrdinal); } else { extraInTo.add(candidateToMatchOrdinal); } candidateToMatchOrdinal = toPopulatedOrdinals.nextSetBit(candidateToMatchOrdinal + 1); } int unmatchedFromOrdinal = fromUnmatchedOrdinals.nextSetBit(0); while(unmatchedFromOrdinal != -1) { extraInFrom.add(unmatchedFromOrdinal); unmatchedFromOrdinal = fromUnmatchedOrdinals.nextSetBit(unmatchedFromOrdinal + 1); } }
public List<Object> extractValues(HollowDataAccess dataAccess, HollowDiffNodeIdentifier fieldIdentifier, int ordinal) { IntList ordinalList = new IntList(1); ordinalList.add(ordinal); return traverse(dataAccess.getTypeDataAccess(getType(fieldIdentifier)), ordinalList, fieldIdentifier, 0); }
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; } };
private void addMatches(Matcher matcher, int fieldIndex, int hashCode, IntList results) { int hashIntCode = HashCodes.hashInt(hashCode); int bucket = hashIntCode & (hashedFieldKeys[fieldIndex].length - 1); while(hashedFieldKeys[fieldIndex][bucket] != -1) { int chainIndex = hashedFieldKeys[fieldIndex][bucket]; int representativeOrdinal = (int)hashedFieldKeyChains.get(chainIndex); if(matcher.foundMatch(representativeOrdinal)) { while(representativeOrdinal != -1) { results.add(representativeOrdinal); chainIndex = (int)(hashedFieldKeyChains.get(chainIndex) >> 32); representativeOrdinal = (chainIndex == Integer.MAX_VALUE) ? -1 : (int)hashedFieldKeyChains.get(chainIndex); } return; } bucket++; bucket &= hashedFieldKeys[fieldIndex].length - 1; } }
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 void putEqualOrdinals(int fromOrdinal, IntList toOrdinals) { long fromOrdinalMapEntry = (long)toOrdinals.get(0) << 32 | fromOrdinal; if(toOrdinals.size() > 1) { fromOrdinalMapEntry = Long.MIN_VALUE | (long)pivotedToOrdinalClusters.size() << 32 | fromOrdinal; for(int i=0;i<toOrdinals.size();i++) { int valueToAdd = toOrdinals.get(i); if(i == toOrdinals.size() - 1) valueToAdd |= Integer.MIN_VALUE; pivotedToOrdinalClusters.add(valueToAdd); } } int hashCode = HashCodes.hashInt(fromOrdinal); int bucket = hashCode & (fromOrdinalsMap.length - 1); while(fromOrdinalsMap[bucket] != -1) bucket = (bucket + 1) & (fromOrdinalsMap.length - 1); fromOrdinalsMap[bucket] = fromOrdinalMapEntry; }
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; } };