private IntMap remapPreviousOrdinalMapping(IntMap previousOrdinalMapping, String typeName, OrdinalRemapper ordinalRemapper) { IntMapEntryIterator ordinalMappingIter = previousOrdinalMapping.iterator(); IntMap ordinalLookupMap = new IntMap(previousOrdinalMapping.size()); while(ordinalMappingIter.next()) ordinalLookupMap.put(ordinalRemapper.getMappedOrdinal(typeName, ordinalMappingIter.getKey()), ordinalMappingIter.getValue()); return ordinalLookupMap; }
public void finish() { IntMapEntryIterator iter = addedOrdinalMap.iterator(); while(iter.next()) { if(removedOrdinalMap.get(iter.getKey()) != -1) numberOfModifiedRecords++; } numberOfNewRecords = addedOrdinalMap.size() - numberOfModifiedRecords; numberOfRemovedRecords = removedOrdinalMap.size() - numberOfModifiedRecords; }
public int get(int key) { int bucket = hashKey(key) % keys.length; while (keys[bucket] != -1) { if (keys[bucket] == key) return values[bucket]; bucket++; if (bucket == keys.length) bucket = 0; } return -1; }
private IntMap copyAllRecords(HollowTypeReadState typeState, DiffEqualityMappingOrdinalRemapper ordinalRemapper, HollowWriteStateEngine writeEngine) { String typeName = typeState.getSchema().getName(); HollowRecordCopier recordCopier = HollowRecordCopier.createCopier(typeState, ordinalRemapper, false); ///NOTE: This will invalidate custom hash codes PopulatedOrdinalListener listener = typeState.getListener(PopulatedOrdinalListener.class); IntMap ordinalLookupMap = new IntMap(listener.getPopulatedOrdinals().cardinality()); int ordinal = listener.getPopulatedOrdinals().nextSetBit(0); while(ordinal != -1) { HollowWriteRecord rec = recordCopier.copy(ordinal); int mappedOrdinal = writeEngine.add(typeName, rec); ordinalLookupMap.put(ordinal, mappedOrdinal); ordinal = listener.getPopulatedOrdinals().nextSetBit(ordinal + 1); } return ordinalLookupMap; }
public int findRemovedOrdinal(int keyOrdinal) { return removedOrdinalMap.get(keyOrdinal); }
@Override public void remapOrdinal(String type, int originalOrdinal, int mappedOrdinal) { IntMap remap = unmatchedOrdinalRemapping.get(type); if(remap == null) throw new IllegalStateException("Must call hintUnmatchedOrdinalCount for type " + type + " before attempting to remap unmatched ordinals"); remap.put(originalOrdinal, mappedOrdinal); }
public IntMapEntryIterator removedOrdinalMappingIterator() { return removedOrdinalMap.iterator(); }
IntMap ordinalLookupMap = new IntMap(shouldCopyAllRecords ? previouslyPopulatedOrdinals.cardinality() : unmatchedRecordCount); int removedMappedOrdinal = writeEngine.add(typeName, rec); ordinalLookupMap.put(matchedToOrdinal, removedMappedOrdinal); int removedMappedOrdinal = writeEngine.add(typeName, rec); ordinalLookupMap.put(nextFreeOrdinal, removedMappedOrdinal);
protected boolean ordinalIsPresent(int ordinal) { return ordinalRemap == null || ordinalRemap.get(ordinal) != -1; }
public void removed(HollowTypeReadState typeState, int stateEngineOrdinal, int mappedOrdinal) { int recordKeyOrdinal = keyIndex.findKeyIndexOrdinal((HollowObjectTypeReadState)typeState, stateEngineOrdinal); removedOrdinalMap.put(recordKeyOrdinal, mappedOrdinal); }
public void hintUnmatchedOrdinalCount(String type, int numOrdinals) { unmatchedOrdinalRemapping.put(type, new IntMap(numOrdinals)); }
public IntMapEntryIterator addedOrdinalMappingIterator() { return addedOrdinalMap.iterator(); }
public HollowHistoricalStateTypeKeyOrdinalMapping remap(OrdinalRemapper remapper) { IntMap newAddedOrdinalMap = new IntMap(addedOrdinalMap.size()); IntMapEntryIterator addedIter = addedOrdinalMap.iterator(); while(addedIter.next()) newAddedOrdinalMap.put(addedIter.getKey(), remapper.getMappedOrdinal(typeName, addedIter.getValue())); IntMap newRemovedOrdinalMap = new IntMap(removedOrdinalMap.size()); IntMapEntryIterator removedIter = removedOrdinalMap.iterator(); while(removedIter.next()) newRemovedOrdinalMap.put(removedIter.getKey(), remapper.getMappedOrdinal(typeName, removedIter.getValue())); return new HollowHistoricalStateTypeKeyOrdinalMapping(typeName, keyIndex, newAddedOrdinalMap, newRemovedOrdinalMap); }
private void remapTheChangedDataToUnusedOrdinals() { PartialOrdinalRemapper remapper = new PartialOrdinalRemapper(); for(HollowSchema schema : schemas) { BitSet ordinalsToRemap = changedOrdinalsBetweenStates.get(schema.getName()); HollowTypeReadState fromTypeState = from.getTypeState(schema.getName()); HollowTypeReadState toTypeState = to.getTypeState(schema.getName()); HollowTypeWriteState typeWriteState = writeEngine.getTypeState(schema.getName()); IntMap ordinalRemapping = new IntMap(ordinalsToRemap.cardinality()); int nextFreeOrdinal = Math.max(fromTypeState.maxOrdinal(), toTypeState.maxOrdinal()) + 1; boolean preserveHashPositions = shouldPreserveHashPositions(schema); HollowRecordCopier copier = HollowRecordCopier.createCopier(fromTypeState, schema, remapper, preserveHashPositions); int ordinal = ordinalsToRemap.nextSetBit(0); while(ordinal != -1 && ordinal <= fromTypeState.maxOrdinal()) { HollowWriteRecord copy = copier.copy(ordinal); typeWriteState.mapOrdinal(copy, nextFreeOrdinal, false, true); ordinalRemapping.put(ordinal, nextFreeOrdinal++); ordinal = ordinalsToRemap.nextSetBit(ordinal + 1); } remapper.addOrdinalRemapping(schema.getName(), ordinalRemapping); typeWriteState.recalculateFreeOrdinals(); } }
protected int getMappedOrdinal(int ordinal) { return ordinalRemap == null ? ordinal : ordinalRemap.get(ordinal); }
public void added(HollowTypeReadState typeState, int ordinal) { int recordKeyOrdinal = keyIndex.findKeyIndexOrdinal((HollowObjectTypeReadState)typeState, ordinal); addedOrdinalMap.put(recordKeyOrdinal, ordinal); }
private void populateStats() { iter.reset(); int removedEntryCount = 0; long totalElementCount = 0; int ordinal = iter.next(); while(ordinal != ORDINAL_NONE) { removedEntryCount++; totalElementCount += typeState.size(ordinal); ordinal = iter.next(); } historicalDataElements.maxOrdinal = removedEntryCount - 1; historicalDataElements.totalNumberOfElements = totalElementCount; historicalDataElements.bitsPerListPointer = totalElementCount == 0 ? 1 : 64 - Long.numberOfLeadingZeros(totalElementCount); historicalDataElements.bitsPerElement = stateEngineDataElements[0].bitsPerElement; ordinalMapping = new IntMap(removedEntryCount); }
public void put(int key, int value) { int bucket = hashKey(key) % keys.length; while (keys[bucket] != -1) { if (keys[bucket] == key) { values[bucket] = value; return; } bucket++; if (bucket == keys.length) bucket = 0; } keys[bucket] = key; values[bucket] = value; size++; }
IntMap remappedOrdinals = new IntMap(numRelocations); HollowWriteRecord rec = copier.copy(ordinalToRelocate); writeState.mapOrdinal(rec, relocatePosition, false, true); remappedOrdinals.put(ordinalToRelocate, relocatePosition); if(typeRelocatedOrdinals != null) { HollowTypeReadState readState = readEngine.getTypeState(schema.getName()); IntMap remappedOrdinals = new IntMap(typeRelocatedOrdinals.cardinality()); HollowWriteRecord rec = copier.copy(remapOrdinal); int newOrdinal = writeState.add(rec); remappedOrdinals.put(remapOrdinal, newOrdinal); writeState.removeOrdinalFromThisCycle(remapOrdinal);