How to use

HollowSetTypeDataAccess

in

com.netflix.hollow.core.read.dataaccess

@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);
}