@Override public int get(int ordinal, int keyOrdinal) { return currentDataAccess().get(ordinal, keyOrdinal); }
@Override public HollowMapSchema getSchema() { return dataAccess.getSchema(); }
@Override public HollowMapEntryOrdinalIterator iterator(int ordinal) { return dataAccess.ordinalIterator(ordinal); }
private HollowMapCachedDelegate(HollowMapTypeDataAccess dataAccess, HollowMapTypeAPI typeAPI, int ordinal) { int size = dataAccess.size(ordinal); int ordinals[] = new int[HashCodes.hashTableSize(size) * 2]; for(int i=0;i<ordinals.length;i+=2) { long bucketData = dataAccess.relativeBucket(ordinal, i/2); ordinals[i] = (int)(bucketData >> 32); ordinals[i + 1] = (int)bucketData; } this.ordinals = ordinals; this.hashMask = (ordinals.length / 2) - 1; this.size = size; this.dataAccess = dataAccess; this.typeAPI = typeAPI; }
@Override public boolean containsKey(HollowMap<K, V> map, int ordinal, Object key) { HollowMapEntryOrdinalIterator iter; if(getSchema().getHashKey() != null) { iter = dataAccess.ordinalIterator(ordinal); } else { int hashCode = dataAccess.getDataAccess().getHashCodeFinder().hashCode(key); iter = dataAccess.potentialMatchOrdinalIterator(ordinal, hashCode); } while(iter.next()) { if(map.equalsKey(iter.getKey(), key)) return true; } return false; }
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 appendMapStringify(Writer writer, HollowDataAccess dataAccess, HollowMapTypeDataAccess typeDataAccess, int ordinal, int indentation) throws IOException { HollowMapSchema schema = typeDataAccess.getSchema(); int size = typeDataAccess.size(ordinal); HollowObjectSchema keySchema = keyTypeDataAccess.getSchema(); HollowMapEntryOrdinalIterator ordinalIterator = typeDataAccess.ordinalIterator(ordinal);
private void appendMapStringify(Writer writer, HollowDataAccess dataAccess, HollowMapTypeDataAccess typeDataAccess, int ordinal, int indentation) throws IOException { HollowMapSchema schema = typeDataAccess.getSchema(); if(showTypes) writer.append("(").append(schema.getName()).append(")"); if(showOrdinals) writer.append(" (ordinal ").append(Integer.toString(ordinal)).append(")"); indentation++; String keyType = schema.getKeyType(); String valueType = schema.getValueType(); HollowMapEntryOrdinalIterator iter = typeDataAccess.ordinalIterator(ordinal); while(iter.next()) { writer.append(NEWLINE); appendIndentation(writer, indentation); writer.append("k: "); appendStringify(writer, dataAccess, keyType, iter.getKey(), indentation); writer.append(NEWLINE); appendIndentation(writer, indentation); writer.append("v: "); appendStringify(writer, dataAccess, valueType, iter.getValue(), indentation); } }
@Override public int size(int ordinal) { return dataAccess.size(ordinal); }
Assert.assertEquals(3, mapDataAccess.size(i)); Assert.assertEquals(i+1, mapDataAccess.get(i, i)); Assert.assertEquals(i+3, mapDataAccess.get(i, i+2)); Assert.assertEquals(i+5, mapDataAccess.get(i, i+4)); Assert.assertEquals(3, mapDataAccess.size(ordinal)); Assert.assertEquals(expectedValue+1, mapDataAccess.get(ordinal, expectedValue)); Assert.assertEquals(expectedValue+3, mapDataAccess.get(ordinal, expectedValue+2)); Assert.assertEquals(expectedValue+5, mapDataAccess.get(ordinal, expectedValue+4));
@Override public HollowRecord instantiateValue(int valueOrdinal) { return GenericHollowRecordHelper.instantiate(getTypeDataAccess().getDataAccess(), getSchema().getValueType(), valueOrdinal); }
public HollowMapEntryOrdinalIterator potentialMatchOrdinalIterator(int ordinal, int hashCode) { return getTypeDataAccess().potentialMatchOrdinalIterator(ordinal, hashCode); }
@Override public Entry<K, V> findEntry(final HollowMap<K, V> map, int ordinal, Object... hashKey) { final long entryOrdinals = dataAccess.findEntry(ordinal, hashKey); if(entryOrdinals != -1L) return new Map.Entry<K, V>() { @Override public K getKey() { return map.instantiateKey((int)(entryOrdinals >> 32)); } @Override public V getValue() { return map.instantiateValue((int)entryOrdinals); } @Override public V setValue(V value) { throw new UnsupportedOperationException(); } }; return null; }
@Override public boolean next() { long currentBucketValue = dataAccess.relativeBucket(mapOrdinal, currentBucket); int currentBucketKey = (int)(currentBucketValue >>> 32); if(currentBucketKey == ORDINAL_NONE) return false; key = currentBucketKey; value = (int)currentBucketValue; currentBucket++; currentBucket &= numBuckets - 1; return true; }
@Override public K findKey(HollowMap<K, V> map, int ordinal, Object... hashKey) { int keyOrdinal = dataAccess.findKey(ordinal, hashKey); if(keyOrdinal != -1) return map.instantiateKey(keyOrdinal); return null; }
@Override public V findValue(HollowMap<K, V> map, int ordinal, Object... hashKey) { int valueOrdinal = dataAccess.findValue(ordinal, hashKey); if(valueOrdinal != -1) return map.instantiateValue(valueOrdinal); return null; }
@Override public V get(HollowMap<K, V> map, int ordinal, Object key) { HollowMapEntryOrdinalIterator iter; if(getSchema().getHashKey() != null) { iter = dataAccess.ordinalIterator(ordinal); } else { int hashCode = dataAccess.getDataAccess().getHashCodeFinder().hashCode(key); iter = dataAccess.potentialMatchOrdinalIterator(ordinal, hashCode); } while(iter.next()) { if(map.equalsKey(iter.getKey(), key)) return map.instantiateValue(iter.getValue()); } return null; }
HollowMapTypeDataAccess mapAccess = (HollowMapTypeDataAccess)typeDataAccess; boolean isValue = fieldIdentifier.getParents().get(level + 1).getViaFieldName().equals("value"); String childType = isValue ? mapAccess.getSchema().getValueType() : mapAccess.getSchema().getKeyType(); childDataAccess = typeDataAccess.getDataAccess().getTypeDataAccess(childType); for(int i=0;i<ordinals.size();i++) { HollowMapEntryOrdinalIterator iter = mapAccess.ordinalIterator(ordinals.get(i)); while(iter.next()) { childOrdinals.add(isValue ? iter.getValue() : iter.getKey());
public HollowMapEntryOrdinalIteratorImpl(int mapOrdinal, HollowMapTypeDataAccess dataAccess) { this.mapOrdinal = mapOrdinal; this.dataAccess = dataAccess; this.numBuckets = HashCodes.hashTableSize(dataAccess.size(mapOrdinal)); }
@Override public HollowRecord instantiateKey(int keyOrdinal) { return GenericHollowRecordHelper.instantiate(getTypeDataAccess().getDataAccess(), getSchema().getKeyType(), keyOrdinal); }