@Override public int getMappedOrdinal(String type, int originalOrdinal) { return baseRemappers[stateEngineIdx].getMappedOrdinal(type, originalOrdinal); }
@Override public boolean ordinalIsMapped(String type, int originalOrdinal) { return baseRemappers[stateEngineIdx].ordinalIsMapped(type, originalOrdinal); }
@Override public void remapOrdinal(String type, int originalOrdinal, int mappedOrdinal) { baseRemappers[stateEngineIdx].remapOrdinal(type, originalOrdinal, mappedOrdinal); HollowPrimaryKeyIndex[] typeKeyIndexes = this.primaryKeyIndexes.get(type); if(typeKeyIndexes != null) { Object primaryKey[] = typeKeyIndexes[stateEngineIdx].getRecordKey(originalOrdinal); for(int i=0;i<baseRemappers.length;i++) { if(i != stateEngineIdx) { if(typeKeyIndexes[i] != null) { int matchOrdinal = typeKeyIndexes[i].getMatchingOrdinal(primaryKey); if(matchOrdinal != -1) { baseRemappers[i].remapOrdinal(type, matchOrdinal, mappedOrdinal); } } } } } }
private int copy(int ordinal) { if(isOrdinalPopulated(ordinal)) { if(!ordinalRemapper.ordinalIsMapped(getType(), ordinal)) { HollowWriteRecord rec = copier.copy(ordinal); if(hashOrderIndependentOrdinalMap == null) { int outputOrdinal = writeState.add(rec); ordinalRemapper.remapOrdinal(getType(), ordinal, outputOrdinal); return outputOrdinal; } else { scratch.reset(); ((HollowHashableWriteRecord)rec).writeDataTo(scratch, HashBehavior.IGNORED_HASHES); int outputOrdinal = hashOrderIndependentOrdinalMap.get(scratch); if(outputOrdinal != -1) return outputOrdinal; synchronized(hashOrderIndependentOrdinalMap) { outputOrdinal = hashOrderIndependentOrdinalMap.get(scratch); if(outputOrdinal != -1) return outputOrdinal; outputOrdinal = writeState.add(rec); ordinalRemapper.remapOrdinal(getType(), ordinal, outputOrdinal); hashOrderIndependentOrdinalMap.put(scratch, outputOrdinal); } } } return ordinalRemapper.getMappedOrdinal(getType(), ordinal); } return -1; }
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; }
@Override public HollowTypeDataAccess getTypeDataAccess(String typeName, int ordinal) { HollowDataAccess state = this; while(state instanceof HollowHistoricalStateDataAccess) { HollowHistoricalStateDataAccess historicalState = (HollowHistoricalStateDataAccess)state; if(historicalState.getOrdinalMapping().ordinalIsMapped(typeName, ordinal)) return state.getTypeDataAccess(typeName); state = historicalState.getNextState(); } return state.getTypeDataAccess(typeName); }
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); }
@Override public HollowWriteRecord copy(int ordinal) { HollowMapWriteRecord rec = rec(); rec.reset(); HollowMapEntryOrdinalIterator iter = readState().ordinalIterator(ordinal); String keyType = readState().getSchema().getKeyType(); String valueType = readState().getSchema().getValueType(); while(iter.next()) { int remappedKeyOrdinal = ordinalRemapper.getMappedOrdinal(keyType, iter.getKey()); int remappedValueOrdinal = ordinalRemapper.getMappedOrdinal(valueType, iter.getValue()); int hashCode = preserveHashPositions ? ((HollowMapEntryOrdinalIteratorImpl)iter).getCurrentBucket() : remappedKeyOrdinal; rec.addEntry(remappedKeyOrdinal, remappedValueOrdinal, hashCode); } return rec; }
@Override public HollowWriteRecord copy(int ordinal) { HollowListWriteRecord rec = rec(); rec.reset(); String elementType = readState().getSchema().getElementType(); int size = readState().size(ordinal); for(int i=0;i<size;i++) { int elementOrdinal = readState().getElementOrdinal(ordinal, i); int remappedElementOrdinal = ordinalRemapper.getMappedOrdinal(elementType, elementOrdinal); rec.addElement(remappedElementOrdinal); } return rec; }
@Override public HollowWriteRecord copy(int ordinal) { HollowSetWriteRecord rec = rec(); rec.reset(); String elementType = readState().getSchema().getElementType(); HollowOrdinalIterator ordinalIterator = readState().ordinalIterator(ordinal); int elementOrdinal = ordinalIterator.next(); while(elementOrdinal != HollowOrdinalIterator.NO_MORE_ORDINALS) { int remappedElementOrdinal = ordinalRemapper.getMappedOrdinal(elementType, elementOrdinal); int hashCode = preserveHashPositions ? ((HollowSetOrdinalIterator)ordinalIterator).getCurrentBucket() : remappedElementOrdinal; rec.addElement(remappedElementOrdinal, hashCode); elementOrdinal = ordinalIterator.next(); } return rec; }
int ordinalVal = objectReadState.readOrdinal(ordinal, readFieldIndex); if(ordinalVal >= 0) { int remappedOrdinalVal = ordinalRemapper.getMappedOrdinal(readState().getSchema().getReferencedType(readFieldIndex), ordinalVal); rec.setReference(fieldName, remappedOrdinalVal);