- Add the Codota plugin to your IDE and get smart completions
private void myMethod () {Dictionary d =
new Hashtable()
- Smart code suggestions by Tabnine
}
@Override public boolean contains(int ordinal, int value) { return currentDataAccess().contains(ordinal, value); }
public HollowOrdinalIterator potentialMatchOrdinalIterator(int ordinal, int hashCode) { return getTypeDataAccess().potentialMatchOrdinalIterator(ordinal, hashCode); }
@Override public int size(int ordinal) { return dataAccess.size(ordinal); }
private HollowSetCachedDelegate(HollowSetTypeDataAccess dataAccess, HollowSetTypeAPI typeAPI, int ordinal) { int size = dataAccess.size(ordinal); int ordinals[] = new int[HashCodes.hashTableSize(size)]; for(int i=0;i<ordinals.length;i++) { ordinals[i] = dataAccess.relativeBucketValue(ordinal, i); } this.ordinals = ordinals; this.size = size; this.hashMask = ordinals.length - 1; this.dataAccess = dataAccess; this.typeAPI = typeAPI; }
@Override public boolean contains(HollowSet<T> set, int ordinal, Object o) { HollowOrdinalIterator iter; if(getSchema().getHashKey() != null) { iter = dataAccess.ordinalIterator(ordinal); } else { int hashCode = dataAccess.getDataAccess().getHashCodeFinder().hashCode(o); iter = dataAccess.potentialMatchOrdinalIterator(ordinal, hashCode); } int potentialOrdinal = iter.next(); while(potentialOrdinal != HollowOrdinalIterator.NO_MORE_ORDINALS) { if(set.equalsElement(potentialOrdinal, o)) return true; potentialOrdinal = iter.next(); } return false; }
Assert.assertEquals(3, setDataAccess.size(i)); Assert.assertTrue(setDataAccess.contains(i, i)); Assert.assertTrue(setDataAccess.contains(i, i+1)); Assert.assertTrue(setDataAccess.contains(i, i+2)); Assert.assertEquals(3, setDataAccess.size(ordinal)); Assert.assertTrue(setDataAccess.contains(ordinal, expectedValue)); Assert.assertTrue(setDataAccess.contains(ordinal, expectedValue+1)); Assert.assertTrue(setDataAccess.contains(ordinal, expectedValue+2));
private void appendSetStringify(Writer writer, HollowDataAccess dataAccess, HollowSetTypeDataAccess typeDataAccess, int ordinal, int indentation) throws IOException { HollowSetSchema schema = typeDataAccess.getSchema(); if(showTypes) writer.append("(").append(schema.getName()).append(")"); if(showOrdinals) writer.append(" (ordinal ").append(Integer.toString(ordinal)).append(")"); indentation++; String elementType = schema.getElementType(); HollowOrdinalIterator iter = typeDataAccess.ordinalIterator(ordinal); int elementOrdinal = iter.next(); while(elementOrdinal != NO_MORE_ORDINALS) { writer.append(NEWLINE); appendIndentation(writer, indentation); writer.append("e: "); appendStringify(writer, dataAccess, elementType, elementOrdinal, indentation); elementOrdinal = iter.next(); } }
@Override public T findElement(HollowSet<T> set, int ordinal, Object... keys) { int elementOrdinal = dataAccess.findElement(ordinal, keys); if(elementOrdinal != -1) return set.instantiateElement(elementOrdinal); return null; }
@Override public int next() { int currentBucketValue; currentBucketValue = dataAccess.relativeBucketValue(setOrdinal, currentBucket); if(currentBucketValue == ORDINAL_NONE) { return NO_MORE_ORDINALS; } currentBucket++; currentBucket &= (numBuckets - 1); return currentBucketValue; }
@Override public HollowOrdinalIterator iterator(int ordinal) { return dataAccess.ordinalIterator(ordinal); }
@Override public HollowSetSchema getSchema() { return dataAccess.getSchema(); }
@Override public HollowRecord instantiateElement(int elementOrdinal) { return GenericHollowRecordHelper.instantiate(getTypeDataAccess().getDataAccess(), getSchema().getElementType(), elementOrdinal); }
private void appendSetStringify(Writer writer, HollowDataAccess dataAccess, HollowSetTypeDataAccess typeDataAccess, int ordinal, int indentation) throws IOException { HollowSetSchema schema = typeDataAccess.getSchema(); indentation++; String elementType = schema.getElementType(); HollowOrdinalIterator iter = typeDataAccess.ordinalIterator(ordinal); int elementOrdinal = iter.next(); if(elementOrdinal == HollowOrdinalIterator.NO_MORE_ORDINALS) { writer.append("[]"); } else { boolean firstElement = true; writer.append("["); if(prettyPrint) writer.append(NEWLINE); while(elementOrdinal != HollowOrdinalIterator.NO_MORE_ORDINALS) { if(firstElement) firstElement = false; else writer.append(","); if(prettyPrint) appendIndentation(writer, indentation); appendStringify(writer, dataAccess, elementType, elementOrdinal, indentation); elementOrdinal = iter.next(); } if(prettyPrint) { writer.append(NEWLINE); appendIndentation(writer, indentation - 1); } writer.append("]"); } }
@Override public T findElement(HollowSet<T> set, int ordinal, Object... keys) { int elementOrdinal = dataAccess.findElement(ordinal, keys); if(elementOrdinal != -1) return set.instantiateElement(elementOrdinal); return null; }
@Override public int next() { int bucketValue; bucketValue = ORDINAL_NONE; while(bucketValue == ORDINAL_NONE) { currentBucket++; if(currentBucket >= numBuckets) return NO_MORE_ORDINALS; bucketValue = dataAccess.relativeBucketValue(setOrdinal, currentBucket); } return bucketValue; }
public HollowOrdinalIterator getOrdinalIterator(int ordinal) { return getTypeDataAccess().ordinalIterator(ordinal); }
@Override public HollowSetSchema getSchema() { return dataAccess.getSchema(); }
@Override public boolean contains(HollowSet<T> set, int ordinal, Object o) { if(getSchema().getHashKey() != null) { for(int i=0;i<ordinals.length;i++) { if(ordinals[i] != -1 && set.equalsElement(ordinals[i], o)) return true; } } else { int hashCode = dataAccess.getDataAccess().getHashCodeFinder().hashCode(o); int bucket = HashCodes.hashInt(hashCode) & hashMask; while(ordinals[bucket] != -1) { if(set.equalsElement(ordinals[bucket], o)) return true; bucket ++; bucket &= hashMask; } } return false; }
public HollowSetOrdinalIterator(int setOrdinal, HollowSetTypeDataAccess dataAccess) { this.setOrdinal = setOrdinal; this.dataAccess = dataAccess; this.numBuckets = HashCodes.hashTableSize(dataAccess.size(setOrdinal)); }
@Override public boolean contains(int ordinal, int value, int hashCode) { return currentDataAccess().contains(ordinal, value, hashCode); }