From 882de97b5c7ffd2dc3bae51214e26b692f439e3f Mon Sep 17 00:00:00 2001
From: Sunjeet Singh <sunjeets@netflix.com>
Date: Tue, 3 Sep 2024 19:10:09 -0700
Subject: [PATCH] shard holders for other types

---
 .../core/read/engine/HollowTypeReadState.java |  6 ---
 .../HollowListTypeReshardingStrategy.java     |  1 -
 .../list/HollowListTypeShardsHolder.java      | 53 +++++++++++++++++++
 .../map/HollowMapTypeReshardingStrategy.java  |  1 -
 .../engine/map/HollowMapTypeShardsHolder.java | 53 +++++++++++++++++++
 ...llowObjectDeltaHistoricalStateCreator.java |  2 +-
 .../object/HollowObjectTypeReadState.java     | 42 +++++++--------
 .../HollowObjectTypeReshardingStrategy.java   |  1 -
 ...java => HollowObjectTypeShardsHolder.java} | 18 +++++--
 .../set/HollowSetTypeReshardingStrategy.java  |  1 -
 .../engine/set/HollowSetTypeShardsHolder.java | 53 +++++++++++++++++++
 .../object/HollowObjectTypeReadStateTest.java |  6 +--
 12 files changed, 198 insertions(+), 39 deletions(-)
 create mode 100644 hollow/src/main/java/com/netflix/hollow/core/read/engine/list/HollowListTypeShardsHolder.java
 create mode 100644 hollow/src/main/java/com/netflix/hollow/core/read/engine/map/HollowMapTypeShardsHolder.java
 rename hollow/src/main/java/com/netflix/hollow/core/read/engine/object/{ObjectTypeShardsHolder.java => HollowObjectTypeShardsHolder.java} (59%)
 create mode 100644 hollow/src/main/java/com/netflix/hollow/core/read/engine/set/HollowSetTypeShardsHolder.java

diff --git a/hollow/src/main/java/com/netflix/hollow/core/read/engine/HollowTypeReadState.java b/hollow/src/main/java/com/netflix/hollow/core/read/engine/HollowTypeReadState.java
index c1924fc88..bb5e3bed7 100644
--- a/hollow/src/main/java/com/netflix/hollow/core/read/engine/HollowTypeReadState.java
+++ b/hollow/src/main/java/com/netflix/hollow/core/read/engine/HollowTypeReadState.java
@@ -280,12 +280,6 @@ public void reshard(int newNumShards) {
 
                 HollowTypeReadStateShard[] newShards = Arrays.copyOfRange(getShardsVolatile().getShards(), 0, newNumShards);
                 updateShardsVolatile(newShards);
-                // setShardsVolatile(   // SNAP: TODO: constructor has HollowObjectTypeReadStateShard[] parameter
-                //         getShardsVolatile().getClass().getConstructor(HollowTypeReadStateShard[].class).newInstance(
-                //                 newShards
-                //         )
-                //); // SNAP: TODO: is this better addressed with a factory method in the interface, or by switching over to an abstract class?
-                // SNAP: TODO: can do generics with reflective constructor invocation here, or create an abstract method reassignShardsHolder(), or check instanceOf or assignableFrom
 
                 // Re-sharding done.
                 // shardsVolatile now contains newNumShards shards where each shard contains
diff --git a/hollow/src/main/java/com/netflix/hollow/core/read/engine/list/HollowListTypeReshardingStrategy.java b/hollow/src/main/java/com/netflix/hollow/core/read/engine/list/HollowListTypeReshardingStrategy.java
index dd68baacf..ac8035e8b 100644
--- a/hollow/src/main/java/com/netflix/hollow/core/read/engine/list/HollowListTypeReshardingStrategy.java
+++ b/hollow/src/main/java/com/netflix/hollow/core/read/engine/list/HollowListTypeReshardingStrategy.java
@@ -13,7 +13,6 @@ public HollowTypeDataElementsSplitter createDataElementsSplitter(HollowTypeDataE
 
     @Override
     public HollowTypeDataElementsJoiner createDataElementsJoiner(HollowTypeDataElements[] from) {
-        // SNAP: TODO: array casting?
         return new HollowListTypeDataElementsJoiner((HollowListTypeDataElements[]) from);
     }
 }
diff --git a/hollow/src/main/java/com/netflix/hollow/core/read/engine/list/HollowListTypeShardsHolder.java b/hollow/src/main/java/com/netflix/hollow/core/read/engine/list/HollowListTypeShardsHolder.java
new file mode 100644
index 000000000..e81108e5f
--- /dev/null
+++ b/hollow/src/main/java/com/netflix/hollow/core/read/engine/list/HollowListTypeShardsHolder.java
@@ -0,0 +1,53 @@
+package com.netflix.hollow.core.read.engine.list;
+
+import com.netflix.hollow.core.read.engine.HollowTypeReadStateShard;
+import com.netflix.hollow.core.read.engine.ShardsHolder;
+
+public class HollowListTypeShardsHolder extends ShardsHolder {
+    final HollowListTypeReadStateShard shards[];
+    final int shardNumberMask;
+
+    /**
+     * Thread safe construction of ShardHolder with given shards
+     * @param fromShards shards to be used
+     */
+    public HollowListTypeShardsHolder(HollowTypeReadStateShard[] fromShards) {
+        this.shards = new HollowListTypeReadStateShard[fromShards.length];
+        for (int i=0; i<fromShards.length; i++) {
+            this.shards[i] = (HollowListTypeReadStateShard) fromShards[i];
+        }
+        this.shardNumberMask = fromShards.length - 1;
+    }
+
+    /**
+     * Thread safe construction of a ShardHolder which has all the shards from {@code oldShards} except
+     * the shard at index {@code newShardIndex}, using the shard {@code newShard} at that index instead.
+     * @param oldShards original shards
+     * @param newShard a new shard
+     * @param newShardIndex index at which to place the new shard
+     */
+    HollowListTypeShardsHolder(HollowListTypeReadStateShard[] oldShards, HollowListTypeReadStateShard newShard, int newShardIndex) {
+        int numShards = oldShards.length;
+        HollowListTypeReadStateShard[] shards = new HollowListTypeReadStateShard[numShards];
+        for (int i=0; i<numShards; i++) {
+            if (i == newShardIndex) {
+                shards[i] = newShard;
+            } else {
+                shards[i] = oldShards[i];
+            }
+        }
+        this.shards = shards;
+        this.shardNumberMask = numShards - 1;
+    }
+
+    @Override
+    public HollowTypeReadStateShard[] getShards() {
+        throw new UnsupportedOperationException("Not implemented yet");
+        // return shards;
+    }
+
+    @Override
+    public int getShardNumberMask() {
+        return shardNumberMask;
+    }
+}
diff --git a/hollow/src/main/java/com/netflix/hollow/core/read/engine/map/HollowMapTypeReshardingStrategy.java b/hollow/src/main/java/com/netflix/hollow/core/read/engine/map/HollowMapTypeReshardingStrategy.java
index 33cbbb8f7..a0a03aa5d 100644
--- a/hollow/src/main/java/com/netflix/hollow/core/read/engine/map/HollowMapTypeReshardingStrategy.java
+++ b/hollow/src/main/java/com/netflix/hollow/core/read/engine/map/HollowMapTypeReshardingStrategy.java
@@ -13,7 +13,6 @@ public HollowTypeDataElementsSplitter createDataElementsSplitter(HollowTypeDataE
 
     @Override
     public HollowTypeDataElementsJoiner createDataElementsJoiner(HollowTypeDataElements[] from) {
-        // SNAP: TODO: array casting?
         return new HollowMapTypeDataElementsJoiner((HollowMapTypeDataElements[]) from);
     }
 }
diff --git a/hollow/src/main/java/com/netflix/hollow/core/read/engine/map/HollowMapTypeShardsHolder.java b/hollow/src/main/java/com/netflix/hollow/core/read/engine/map/HollowMapTypeShardsHolder.java
new file mode 100644
index 000000000..1ef42922b
--- /dev/null
+++ b/hollow/src/main/java/com/netflix/hollow/core/read/engine/map/HollowMapTypeShardsHolder.java
@@ -0,0 +1,53 @@
+package com.netflix.hollow.core.read.engine.map;
+
+import com.netflix.hollow.core.read.engine.HollowTypeReadStateShard;
+import com.netflix.hollow.core.read.engine.ShardsHolder;
+
+public class HollowMapTypeShardsHolder extends ShardsHolder {
+    final HollowMapTypeReadStateShard shards[];
+    final int shardNumberMask;
+
+    /**
+     * Thread safe construction of ShardHolder with given shards
+     * @param fromShards shards to be used
+     */
+    public HollowMapTypeShardsHolder(HollowTypeReadStateShard[] fromShards) {
+        this.shards = new HollowMapTypeReadStateShard[fromShards.length];
+        for (int i=0; i<fromShards.length; i++) {
+            this.shards[i] = (HollowMapTypeReadStateShard) fromShards[i];
+        }
+        this.shardNumberMask = fromShards.length - 1;
+    }
+
+    /**
+     * Thread safe construction of a ShardHolder which has all the shards from {@code oldShards} except
+     * the shard at index {@code newShardIndex}, using the shard {@code newShard} at that index instead.
+     * @param oldShards original shards
+     * @param newShard a new shard
+     * @param newShardIndex index at which to place the new shard
+     */
+    HollowMapTypeShardsHolder(HollowMapTypeReadStateShard[] oldShards, HollowMapTypeReadStateShard newShard, int newShardIndex) {
+        int numShards = oldShards.length;
+        HollowMapTypeReadStateShard[] shards = new HollowMapTypeReadStateShard[numShards];
+        for (int i=0; i<numShards; i++) {
+            if (i == newShardIndex) {
+                shards[i] = newShard;
+            } else {
+                shards[i] = oldShards[i];
+            }
+        }
+        this.shards = shards;
+        this.shardNumberMask = numShards - 1;
+    }
+
+    @Override
+    public HollowTypeReadStateShard[] getShards() {
+        throw new UnsupportedOperationException("Not implemented yet");
+        // return shards;
+    }
+
+    @Override
+    public int getShardNumberMask() {
+        return shardNumberMask;
+    }
+}
diff --git a/hollow/src/main/java/com/netflix/hollow/core/read/engine/object/HollowObjectDeltaHistoricalStateCreator.java b/hollow/src/main/java/com/netflix/hollow/core/read/engine/object/HollowObjectDeltaHistoricalStateCreator.java
index 4bf2f5e91..0169438aa 100644
--- a/hollow/src/main/java/com/netflix/hollow/core/read/engine/object/HollowObjectDeltaHistoricalStateCreator.java
+++ b/hollow/src/main/java/com/netflix/hollow/core/read/engine/object/HollowObjectDeltaHistoricalStateCreator.java
@@ -40,7 +40,7 @@ public class HollowObjectDeltaHistoricalStateCreator {
     private final HollowObjectTypeDataElements historicalDataElements;
 
     private HollowObjectTypeReadState typeState;
-    private ObjectTypeShardsHolder shardsHolder;
+    private HollowObjectTypeShardsHolder shardsHolder;
     private RemovedOrdinalIterator iter;
     private IntMap ordinalMapping;
     private int nextOrdinal;
diff --git a/hollow/src/main/java/com/netflix/hollow/core/read/engine/object/HollowObjectTypeReadState.java b/hollow/src/main/java/com/netflix/hollow/core/read/engine/object/HollowObjectTypeReadState.java
index dfcdbdc71..c8266e975 100644
--- a/hollow/src/main/java/com/netflix/hollow/core/read/engine/object/HollowObjectTypeReadState.java
+++ b/hollow/src/main/java/com/netflix/hollow/core/read/engine/object/HollowObjectTypeReadState.java
@@ -55,16 +55,16 @@ public class HollowObjectTypeReadState extends HollowTypeReadState implements Ho
 
     private int maxOrdinal;
 
-    volatile ObjectTypeShardsHolder shardsVolatile;
+    volatile HollowObjectTypeShardsHolder shardsVolatile;
 
     @Override
-    public ObjectTypeShardsHolder getShardsVolatile() {
+    public HollowObjectTypeShardsHolder getShardsVolatile() {
         return shardsVolatile;
     }
 
     @Override
     public void updateShardsVolatile(HollowTypeReadStateShard[] shards) {
-        this.shardsVolatile = new ObjectTypeShardsHolder(shards);
+        this.shardsVolatile = new HollowObjectTypeShardsHolder(shards);
     }
 
     @Override
@@ -90,7 +90,7 @@ public HollowObjectTypeReadState(HollowObjectSchema schema, HollowObjectTypeData
         this.unfilteredSchema = schema;
 
         HollowObjectTypeReadStateShard newShard = new HollowObjectTypeReadStateShard(schema, dataElements, 0);
-        this.shardsVolatile = new ObjectTypeShardsHolder(new HollowObjectTypeReadStateShard[] {newShard});
+        this.shardsVolatile = new HollowObjectTypeShardsHolder(new HollowObjectTypeReadStateShard[] {newShard});
         this.maxOrdinal = dataElements.maxOrdinal;
     }
 
@@ -121,7 +121,7 @@ public void readSnapshot(HollowBlobInput in, ArraySegmentRecycler memoryRecycler
             shardDataElements.readSnapshot(in, unfilteredSchema);
             newShards[i] = new HollowObjectTypeReadStateShard(getSchema(), shardDataElements, shardOrdinalShift);
         }
-        shardsVolatile = new ObjectTypeShardsHolder(newShards);
+        shardsVolatile = new HollowObjectTypeShardsHolder(newShards);
 
         if(shardsVolatile.shards.length == 1)
             maxOrdinal = shardsVolatile.shards[0].dataElements.maxOrdinal;
@@ -165,7 +165,7 @@ public void applyDelta(HollowBlobInput in, HollowSchema deltaSchema, ArraySegmen
                 nextData.applyDelta(oldData, deltaData);
 
                 HollowObjectTypeReadStateShard newShard = new HollowObjectTypeReadStateShard(getSchema(), nextData, shardsVolatile.shards[i].shardOrdinalShift);
-                shardsVolatile = new ObjectTypeShardsHolder(shardsVolatile.shards, newShard, i);
+                shardsVolatile = new HollowObjectTypeShardsHolder(shardsVolatile.shards, newShard, i);
 
                 notifyListenerAboutDeltaChanges(deltaData.encodedRemovals, deltaData.encodedAdditions, i, shardsVolatile.shards.length);
                 deltaData.encodedAdditions.destroy();
@@ -197,7 +197,7 @@ public static void discardType(HollowBlobInput in, HollowObjectSchema schema, in
     public boolean isNull(int ordinal, int fieldIndex) {
         sampler.recordFieldAccess(fieldIndex);
 
-        ObjectTypeShardsHolder shardsHolder;
+        HollowObjectTypeShardsHolder shardsHolder;
         HollowObjectTypeReadStateShard shard;
         long fixedLengthValue;
 
@@ -225,7 +225,7 @@ public boolean isNull(int ordinal, int fieldIndex) {
     public int readOrdinal(int ordinal, int fieldIndex) {
         sampler.recordFieldAccess(fieldIndex);
 
-        ObjectTypeShardsHolder shardsHolder;
+        HollowObjectTypeShardsHolder shardsHolder;
         HollowObjectTypeReadStateShard shard;
         long refOrdinal;
 
@@ -244,7 +244,7 @@ public int readOrdinal(int ordinal, int fieldIndex) {
     public int readInt(int ordinal, int fieldIndex) {
         sampler.recordFieldAccess(fieldIndex);
 
-        ObjectTypeShardsHolder shardsHolder;
+        HollowObjectTypeShardsHolder shardsHolder;
         HollowObjectTypeReadStateShard shard;
         long value;
 
@@ -263,7 +263,7 @@ public int readInt(int ordinal, int fieldIndex) {
     public float readFloat(int ordinal, int fieldIndex) {
         sampler.recordFieldAccess(fieldIndex);
 
-        ObjectTypeShardsHolder shardsHolder;
+        HollowObjectTypeShardsHolder shardsHolder;
         HollowObjectTypeReadStateShard shard;
         int value;
 
@@ -282,7 +282,7 @@ public float readFloat(int ordinal, int fieldIndex) {
     public double readDouble(int ordinal, int fieldIndex) {
         sampler.recordFieldAccess(fieldIndex);
 
-        ObjectTypeShardsHolder shardsHolder;
+        HollowObjectTypeShardsHolder shardsHolder;
         HollowObjectTypeReadStateShard shard;
         long value;
 
@@ -301,7 +301,7 @@ public double readDouble(int ordinal, int fieldIndex) {
     public long readLong(int ordinal, int fieldIndex) {
         sampler.recordFieldAccess(fieldIndex);
 
-        ObjectTypeShardsHolder shardsHolder;
+        HollowObjectTypeShardsHolder shardsHolder;
         HollowObjectTypeReadStateShard shard;
         long value;
 
@@ -320,7 +320,7 @@ public long readLong(int ordinal, int fieldIndex) {
     public Boolean readBoolean(int ordinal, int fieldIndex) {
         sampler.recordFieldAccess(fieldIndex);
 
-        ObjectTypeShardsHolder shardsHolder;
+        HollowObjectTypeShardsHolder shardsHolder;
         HollowObjectTypeReadStateShard shard;
         long value;
 
@@ -339,7 +339,7 @@ public Boolean readBoolean(int ordinal, int fieldIndex) {
     public byte[] readBytes(int ordinal, int fieldIndex) {
         sampler.recordFieldAccess(fieldIndex);
 
-        ObjectTypeShardsHolder shardsHolder;
+        HollowObjectTypeShardsHolder shardsHolder;
         HollowObjectTypeReadStateShard shard;
         byte[] result;
         int numBitsForField;
@@ -370,7 +370,7 @@ public byte[] readBytes(int ordinal, int fieldIndex) {
     public String readString(int ordinal, int fieldIndex) {
         sampler.recordFieldAccess(fieldIndex);
 
-        ObjectTypeShardsHolder shardsHolder;
+        HollowObjectTypeShardsHolder shardsHolder;
         HollowObjectTypeReadStateShard shard;
         String result;
         int numBitsForField;
@@ -401,7 +401,7 @@ public String readString(int ordinal, int fieldIndex) {
     public boolean isStringFieldEqual(int ordinal, int fieldIndex, String testValue) {
         sampler.recordFieldAccess(fieldIndex);
 
-        ObjectTypeShardsHolder shardsHolder;
+        HollowObjectTypeShardsHolder shardsHolder;
         HollowObjectTypeReadStateShard shard;
         boolean result;
         int numBitsForField;
@@ -432,7 +432,7 @@ public boolean isStringFieldEqual(int ordinal, int fieldIndex, String testValue)
     public int findVarLengthFieldHashCode(int ordinal, int fieldIndex) {
         sampler.recordFieldAccess(fieldIndex);
 
-        ObjectTypeShardsHolder shardsHolder;
+        HollowObjectTypeShardsHolder shardsHolder;
         HollowObjectTypeReadStateShard shard;
         int hashCode;
         int numBitsForField;
@@ -459,7 +459,7 @@ public int findVarLengthFieldHashCode(int ordinal, int fieldIndex) {
         return hashCode;
     }
 
-    private boolean readWasUnsafe(ObjectTypeShardsHolder shardsHolder, int ordinal, HollowObjectTypeReadStateShard shard) {
+    private boolean readWasUnsafe(HollowObjectTypeShardsHolder shardsHolder, int ordinal, HollowObjectTypeReadStateShard shard) {
         // Use a load (acquire) fence to constrain the compiler reordering prior plain loads so
         // that they cannot "float down" below the volatile load of shardsVolatile.
         // This ensures data is checked against current shard holder *after* optimistic calculations
@@ -487,7 +487,7 @@ private boolean readWasUnsafe(ObjectTypeShardsHolder shardsHolder, int ordinal,
         // [Comment credit: Paul Sandoz]
         //
         HollowUnsafeHandle.getUnsafe().loadFence();
-        ObjectTypeShardsHolder currShardsHolder = shardsVolatile;   // SNAP: TODO: cant cast here
+        HollowObjectTypeShardsHolder currShardsHolder = shardsVolatile;
         // Validate against the underlying shard so that, during a delta application that involves re-sharding the worst
         // case no. of times a read will be invalidated is 3: when shards are expanded or truncated, when a shard is affected
         // by a split or join, and finally when delta is applied to a shard. If only shardsHolder was checked here, the
@@ -529,7 +529,7 @@ protected void invalidate() {
         for (int i=0;i<numShards;i++) {
             newShards[i] = new HollowObjectTypeReadStateShard(getSchema(), null, shards[i].shardOrdinalShift);
         }
-        this.shardsVolatile = new ObjectTypeShardsHolder(newShards);
+        this.shardsVolatile = new HollowObjectTypeShardsHolder(newShards);
     }
 
     @Override
@@ -558,7 +558,7 @@ HollowObjectTypeDataElements[] currentDataElements() {
 
     @Override
     protected void applyToChecksum(HollowChecksum checksum, HollowSchema withSchema) {
-        final ObjectTypeShardsHolder shardsHolder = this.shardsVolatile;
+        final HollowObjectTypeShardsHolder shardsHolder = this.shardsVolatile;
         final HollowObjectTypeReadStateShard[] shards = shardsHolder.shards;
         int shardNumberMask = shardsHolder.shardNumberMask;
         if(!(withSchema instanceof HollowObjectSchema))
diff --git a/hollow/src/main/java/com/netflix/hollow/core/read/engine/object/HollowObjectTypeReshardingStrategy.java b/hollow/src/main/java/com/netflix/hollow/core/read/engine/object/HollowObjectTypeReshardingStrategy.java
index e60f22e1c..1a8f75776 100644
--- a/hollow/src/main/java/com/netflix/hollow/core/read/engine/object/HollowObjectTypeReshardingStrategy.java
+++ b/hollow/src/main/java/com/netflix/hollow/core/read/engine/object/HollowObjectTypeReshardingStrategy.java
@@ -13,7 +13,6 @@ public HollowTypeDataElementsSplitter createDataElementsSplitter(HollowTypeDataE
 
     @Override
     public HollowTypeDataElementsJoiner createDataElementsJoiner(HollowTypeDataElements[] from) {
-        // SNAP: TODO: array casting?
         return new HollowObjectTypeDataElementsJoiner((HollowObjectTypeDataElements[]) from);
     }
 }
diff --git a/hollow/src/main/java/com/netflix/hollow/core/read/engine/object/ObjectTypeShardsHolder.java b/hollow/src/main/java/com/netflix/hollow/core/read/engine/object/HollowObjectTypeShardsHolder.java
similarity index 59%
rename from hollow/src/main/java/com/netflix/hollow/core/read/engine/object/ObjectTypeShardsHolder.java
rename to hollow/src/main/java/com/netflix/hollow/core/read/engine/object/HollowObjectTypeShardsHolder.java
index 2c30d0278..1ad8b2fb2 100644
--- a/hollow/src/main/java/com/netflix/hollow/core/read/engine/object/ObjectTypeShardsHolder.java
+++ b/hollow/src/main/java/com/netflix/hollow/core/read/engine/object/HollowObjectTypeShardsHolder.java
@@ -3,11 +3,15 @@
 import com.netflix.hollow.core.read.engine.HollowTypeReadStateShard;
 import com.netflix.hollow.core.read.engine.ShardsHolder;
 
-public class ObjectTypeShardsHolder extends ShardsHolder {
+public class HollowObjectTypeShardsHolder extends ShardsHolder {
     final HollowObjectTypeReadStateShard shards[];
     final int shardNumberMask;
 
-    public ObjectTypeShardsHolder(HollowTypeReadStateShard[] fromShards) {
+    /**
+     * Thread safe construction of ShardHolder with given shards
+     * @param fromShards shards to be used
+     */
+    public HollowObjectTypeShardsHolder(HollowTypeReadStateShard[] fromShards) {
         this.shards = new HollowObjectTypeReadStateShard[fromShards.length];
         for (int i=0; i<fromShards.length; i++) {
             this.shards[i] = (HollowObjectTypeReadStateShard) fromShards[i];
@@ -15,8 +19,14 @@ public ObjectTypeShardsHolder(HollowTypeReadStateShard[] fromShards) {
         this.shardNumberMask = fromShards.length - 1;
     }
 
-    // SNAP: TODO: javadoc: supports thread-safe construction
-    ObjectTypeShardsHolder(HollowObjectTypeReadStateShard[] oldShards, HollowObjectTypeReadStateShard newShard, int newShardIndex) {
+    /**
+     * Thread safe construction of a ShardHolder which has all the shards from {@code oldShards} except
+     * the shard at index {@code newShardIndex}, using the shard {@code newShard} at that index instead.
+     * @param oldShards original shards
+     * @param newShard a new shard
+     * @param newShardIndex index at which to place the new shard
+     */
+    HollowObjectTypeShardsHolder(HollowObjectTypeReadStateShard[] oldShards, HollowObjectTypeReadStateShard newShard, int newShardIndex) {
         int numShards = oldShards.length;
         HollowObjectTypeReadStateShard[] shards = new HollowObjectTypeReadStateShard[numShards];
         for (int i=0; i<numShards; i++) {
diff --git a/hollow/src/main/java/com/netflix/hollow/core/read/engine/set/HollowSetTypeReshardingStrategy.java b/hollow/src/main/java/com/netflix/hollow/core/read/engine/set/HollowSetTypeReshardingStrategy.java
index 505a92094..e2bd4f32f 100644
--- a/hollow/src/main/java/com/netflix/hollow/core/read/engine/set/HollowSetTypeReshardingStrategy.java
+++ b/hollow/src/main/java/com/netflix/hollow/core/read/engine/set/HollowSetTypeReshardingStrategy.java
@@ -13,7 +13,6 @@ public HollowTypeDataElementsSplitter createDataElementsSplitter(HollowTypeDataE
 
     @Override
     public HollowTypeDataElementsJoiner createDataElementsJoiner(HollowTypeDataElements[] from) {
-        // SNAP: TODO: array casting?
         return new HollowSetTypeDataElementsJoiner((HollowSetTypeDataElements[]) from);
     }
 }
diff --git a/hollow/src/main/java/com/netflix/hollow/core/read/engine/set/HollowSetTypeShardsHolder.java b/hollow/src/main/java/com/netflix/hollow/core/read/engine/set/HollowSetTypeShardsHolder.java
new file mode 100644
index 000000000..f52c5faf3
--- /dev/null
+++ b/hollow/src/main/java/com/netflix/hollow/core/read/engine/set/HollowSetTypeShardsHolder.java
@@ -0,0 +1,53 @@
+package com.netflix.hollow.core.read.engine.set;
+
+import com.netflix.hollow.core.read.engine.HollowTypeReadStateShard;
+import com.netflix.hollow.core.read.engine.ShardsHolder;
+
+public class HollowSetTypeShardsHolder extends ShardsHolder {
+    final HollowSetTypeReadStateShard shards[];
+    final int shardNumberMask;
+
+    /**
+     * Thread safe construction of ShardHolder with given shards
+     * @param fromShards shards to be used
+     */
+    public HollowSetTypeShardsHolder(HollowTypeReadStateShard[] fromShards) {
+        this.shards = new HollowSetTypeReadStateShard[fromShards.length];
+        for (int i=0; i<fromShards.length; i++) {
+            this.shards[i] = (HollowSetTypeReadStateShard) fromShards[i];
+        }
+        this.shardNumberMask = fromShards.length - 1;
+    }
+
+    /**
+     * Thread safe construction of a ShardHolder which has all the shards from {@code oldShards} except
+     * the shard at index {@code newShardIndex}, using the shard {@code newShard} at that index instead.
+     * @param oldShards original shards
+     * @param newShard a new shard
+     * @param newShardIndex index at which to place the new shard
+     */
+    HollowSetTypeShardsHolder(HollowSetTypeReadStateShard[] oldShards, HollowSetTypeReadStateShard newShard, int newShardIndex) {
+        int numShards = oldShards.length;
+        HollowSetTypeReadStateShard[] shards = new HollowSetTypeReadStateShard[numShards];
+        for (int i=0; i<numShards; i++) {
+            if (i == newShardIndex) {
+                shards[i] = newShard;
+            } else {
+                shards[i] = oldShards[i];
+            }
+        }
+        this.shards = shards;
+        this.shardNumberMask = numShards - 1;
+    }
+
+    @Override
+    public HollowTypeReadStateShard[] getShards() {
+        throw new UnsupportedOperationException("Not implemented yet");
+        // return shards;
+    }
+
+    @Override
+    public int getShardNumberMask() {
+        return shardNumberMask;
+    }
+}
diff --git a/hollow/src/test/java/com/netflix/hollow/core/read/engine/object/HollowObjectTypeReadStateTest.java b/hollow/src/test/java/com/netflix/hollow/core/read/engine/object/HollowObjectTypeReadStateTest.java
index 6126b2bcc..f60d9e6e1 100644
--- a/hollow/src/test/java/com/netflix/hollow/core/read/engine/object/HollowObjectTypeReadStateTest.java
+++ b/hollow/src/test/java/com/netflix/hollow/core/read/engine/object/HollowObjectTypeReadStateTest.java
@@ -140,7 +140,7 @@ public void testReshardingIntermediateStages_expandWithOriginalDataElements() th
             {
                 HollowObjectTypeReadState expectedTypeState = populateTypeStateWith(numRecords);
 
-                ObjectTypeShardsHolder original = expectedTypeState.shardsVolatile;
+                HollowObjectTypeShardsHolder original = expectedTypeState.shardsVolatile;
                 HollowObjectTypeReadState actualTypeState = new HollowObjectTypeReadState(readStateEngine, MemoryMode.ON_HEAP, schema, schema);
                 actualTypeState.updateShardsVolatile(expectedTypeState.expandWithOriginalDataElements(original, shardingFactor));
 
@@ -157,7 +157,7 @@ public void testReshardingIntermediateStages_splitDataElementsForOneShard() thro
             {
                 HollowObjectTypeReadState typeState = populateTypeStateWith(numRecords);
 
-                ObjectTypeShardsHolder originalShardsHolder = typeState.shardsVolatile;
+                HollowObjectTypeShardsHolder originalShardsHolder = typeState.shardsVolatile;
                 int originalNumShards = typeState.numShards();
 
                 // expand shards
@@ -183,7 +183,7 @@ public void testReshardingIntermediateStages_joinDataElementsForOneShard() throw
             for (int numRecords = 75000; numRecords <= 100000; numRecords += new Random().nextInt(1000)) {
                 HollowObjectTypeReadState typeState = populateTypeStateWith(numRecords);
 
-                ObjectTypeShardsHolder originalShardsHolder = typeState.shardsVolatile;
+                HollowObjectTypeShardsHolder originalShardsHolder = typeState.shardsVolatile;
                 int originalNumShards = typeState.numShards();
                 assertEquals(8, originalNumShards);