Initial commit

Author: AzureTriple

src/main/java/azuretriple/primitivecontainer/ArrayBitSet.java

@@ -0,0 +1,58 @@
+package azuretriple.primitivecontainer;
+
+import static azuretriple.primitivecontainer.BitSet.major;
+import static azuretriple.primitivecontainer.BitSet.mask;
+
+/** A bit set backed by a {@code long} array. */
+public abstract class ArrayBitSet implements BitSet
+{
+    /** @return The backing array. Changes to this array affect the set. */
+    public abstract long[] data();
+    abstract void sizeLogic(final int major);
+    
+    @Override
+    public void set(final int v)
+    {
+        final int major = major(v);
+        sizeLogic(major);
+        data()[major] |= mask(v);
+    }
+    @Override
+    public void unset(final int v)
+    {
+        final int major = major(v);
+        if(major >= data().length) return;
+        data()[major] &= ~mask(v);
+    }
+    @Override
+    public boolean add(final int v)
+    {
+        final int major = major(v);
+        sizeLogic(major);
+        return data()[major] != (data()[major] |= mask(v));
+    }
+    @Override
+    public boolean remove(final int v)
+    {
+        final int major = major(v);
+        if(major >= data().length) return false;
+        final long mask = mask(v);
+        final boolean out = (data()[major] & mask) != 0L;
+        data()[major] &= ~mask;
+        return out;
+    }
+    @Override
+    public boolean test(final int v)
+    {
+        final int major = major(v);
+        return major < data().length && (data()[major] & mask(v)) != 0L;
+    }
+    
+    @Override
+    public boolean equals(final Object obj)
+    {
+        return obj instanceof final BitSet b && BitSet.equals(this,b);
+    }
+    
+    @Override public abstract ArrayBitSet clone();
+}

src/main/java/azuretriple/primitivecontainer/BitSet.java

@@ -0,0 +1,132 @@
+package azuretriple.primitivecontainer;
+
+/** A set which stores bit-packed boolean values. */
+public interface BitSet extends Cloneable
+{
+    static int major(final int v) {return v >>> 6;}
+    static long mask(final int v) {return 1L << (v & ((1 << 6) - 1));}
+    
+    static boolean equals(final BitSet a,final BitSet b)
+    {
+        if(a == b) return true;
+        final boolean f1 = a instanceof ArrayBitSet,
+                      f2 = b instanceof ArrayBitSet;
+        if(f1 && f2) // Both sets are backed by an array.
+        {
+            final boolean g1 = a instanceof GrowableBitSet,
+                          g2 = b instanceof GrowableBitSet;
+            // The logic can be simplified for two growable bit sets since their exact sizes are tracked.
+            if(g1 && g2)
+            {
+                final GrowableBitSet ga = (GrowableBitSet)a,
+                                     gb = (GrowableBitSet)b;
+                // If the index of the highest non-zero values of both sets differ, then the sets are
+                // obviously not equal.
+                if(ga.highest != gb.highest) return false;
+                final long[] da = ga.set,db = gb.set;
+                // Iterate through both sets, returning false if any values differ.
+                for(int i = 0;i <= ga.highest;++i) if(da[i] != db[i]) return false;
+                return true;
+            }
+            // Get the data and lengths such that (||*a|| < ||*b||).
+            final int la,lb;
+            final long[] da,db;
+            {
+                final ArrayBitSet a1 = (ArrayBitSet)a,
+                                  b1 = (ArrayBitSet)b;
+                final int al = g1? ((GrowableBitSet)a1).highest + 1 : a1.data().length,
+                          bl = g2? ((GrowableBitSet)b1).highest + 1 : b1.data().length;
+                if(al < bl)
+                {
+                    // If the larger set is growable, that guarantees there is a value outside the smaller
+                    // set since the growable set tracks its size to the last value.
+                    if(g2) return false;
+                    la = al;
+                    lb = bl;
+                    da = a1.data();
+                    db = b1.data();
+                }
+                else
+                {
+                    // ^^^ ditto
+                    if(g1 && al != bl) return false;
+                    la = bl;
+                    lb = al;
+                    da = b1.data();
+                    db = a1.data();
+                }
+            }
+            int bi = 0;
+            // Iterate through the smaller set, returning false if the corresponding value in the larger
+            // set does not match.
+            for(int ai = 0;ai < la;++ai,++bi) if(da[ai] != db[bi]) return false;
+            // Iterate through the remainder of the larger set, returning false if any values are non-zero.
+            while(bi < lb) if(db[bi++] != 0L) return false;
+            return true;
+        }
+        if(f1 == f2) // Both sets are backed by a map.
+        {
+            final MapBitSet ma = (MapBitSet)a,mb = (MapBitSet)b;
+            return ma.keys.equals(mb.keys) && ma.values.equals(mb.values);
+        }
+        final ArrayBitSet sa;
+        final MapBitSet sb;
+        if(f1)
+        {
+            sa = (ArrayBitSet)a;
+            sb = (MapBitSet)b;
+        }
+        else
+        {
+            sa = (ArrayBitSet)b;
+            sb = (MapBitSet)a;
+        }
+        final IntList k = sb.keys.data();
+        final long[] data = sa.data();
+        final int al = sa instanceof final GrowableBitSet g? g.highest+1 : data.length,
+                  bl = k.size();
+        // If 'sb' is empty, ensure that 'sa' is too.
+        if(bl == 0) {for(int i = 0;i < al;++i) if(data[i] != 0L) return false;}
+        else
+        {
+            final int[] kd = k.data();
+            // There is guaranteed to be at least one value outside 'sa' if size of its array is less than the
+            // last key in 'sb'.
+            if(al < kd[bl-1]+1) return false;
+            final long[] v = sb.values.data();
+            int ai = 0;
+            for(int bi = 0;bi < bl;++bi)
+            {
+                // Iterate through all values in 'sa' between the previous and current key of 'sb', returning if
+                // any are non-zero.
+                while(ai < kd[bi]) if(data[ai++] != 0L) return false;
+                // The value at the current key in both sets must match.
+                if(data[ai++] != v[bi]) return false;
+            }
+            // All remaining values in 'sa' must be zero.
+            while(ai < al) if(data[ai++] != 0L) return false;
+        }
+        return true;
+    }
+    
+    /** Sets the bit at the position specified by the argument. */
+    void set(final int v);
+    /** Clears the bit at the position specified by the argument. */
+    void unset(final int v);
+    /**
+     * Sets the bit at the position specified by the argument.
+     * @return {@code true} iff the set changed as a result of calling this function.
+     */
+    boolean add(final int v);
+    /**
+     * Clears the bit at the position specified by the argument.
+     * @return {@code true} iff the set changed as a result of calling this function.
+     */
+    boolean remove(final int v);
+    /** @return {@code true} iff the bit at the position specified by the argument is set. */
+    boolean test(final int v);
+    /** Clears all bits in this set. */
+    void clear();
+    
+    BitSet clone();
+}

src/main/java/azuretriple/primitivecontainer/ByteContainer.java

@@ -0,0 +1,12 @@
+package azuretriple.primitivecontainer;
+
+/** A container which holds {@code byte}s. */
+public interface ByteContainer extends PrimitiveContainer
+{
+    /** @return The backing array. Changes to this array affect the container. */
+    default byte[] data() {return (byte[])((Container)this).arr;}
+    /** @return A copy of all the values in this container in order. */
+    default byte[] array() {return (byte[])((Container)this).arrayImpl();}
+    
+    @Override ByteContainer clone();
+}

src/main/java/azuretriple/primitivecontainer/ByteList.java

@@ -0,0 +1,52 @@
+package azuretriple.primitivecontainer;
+
+/** A list containing {@code byte}s. */
+public interface ByteList extends ByteContainer
+{
+    /** @return {@code true} iff this list contains the same data as the argument. */
+    default boolean equals(final ByteList other)
+    {
+        if(this == other) return true;
+        final int s1 = ((List)this).size;
+        if(s1 != ((List)other).size) return false;
+        final byte[] d1 = data(),d2 = other.data();
+        for(int i = 0;i < s1;++i) if(d1[i] != d2[i]) return false;
+        return true;
+    }
+    
+    /** @return The value at the location specified by the argument. */
+    default byte get(final int location)
+    {
+        // Could throw out-of-bounds, but that would mean a branch on a potential hot path.
+        assert location < ((List)this).size;
+    
+        return data()[location];
+    }
+    /** Sets the value at the specified location to the second argument. */
+    default void set(final int location,final byte v)
+    {
+        // Could throw out-of-bounds, but that would mean a branch on a potential hot path.
+        assert location < ((List)this).size;
+        
+        data()[location] = v;
+    }
+    
+    /** Appends the values in the argument to the end of the list. */
+    default void add(final byte[] v) {((List)this).add(v);}
+    /** Appends the argument to the end of the list. */
+    default void add(final byte v) {((List)this).addLogic(); data()[((List)this).size++] = v;}
+    /** Inserts the specified values immediately before the specified location. */
+    default void insert(final int location,final byte[] v) {((List)this).insert(location,v);}
+    /** Inserts the specified value immediately before the specified location. */
+    default void insert(final int location,final byte v) {((List)this).insertLogic(location); data()[location] = v;}
+    /** Removes the last value from the list. */
+    void delete();
+    /** Removes the value at the specified location from the list. */
+    void remove(final int location);
+    /** Removes and returns the last value from the list. */
+    default byte pop() {delete(); return data()[((List)this).size];}
+    /** Removes and returns the value at the specified location from the list. */
+    default byte extract(final int location) {final byte o = data()[location]; remove(location); return o;}
+    
+    @Override ByteList clone();
+}

src/main/java/azuretriple/primitivecontainer/ByteQueue.java

@@ -0,0 +1,33 @@
+package azuretriple.primitivecontainer;
+
+/** A queue containing {@code byte}s. */
+public interface ByteQueue extends ByteContainer
+{
+    /** @return {@code true} iff this queue contains the same data as the argument. */
+    default boolean equals(final ByteQueue other)
+    {
+        if(this == other) return true;
+        final int s1 = size();
+        if(s1 != other.size()) return false;
+        final int l1 = data().length,l2 = other.data().length;
+        for(int i = 0,a = ((Queue)this).start,b = ((Queue)other).start;i != s1;++i,a = (a+1)%l1,b = (b+1)%l2)
+            if(data()[a] != other.data()[b])
+                return false;
+        return true;
+    }
+    
+    /** Appends the values in the argument to the queue. */
+    default void push(final byte[] v) {((Queue)this).push(v);}
+    /** Appends the value to the queue. */
+    default void push(final byte v) {((Queue)this).pushLogic(); data()[((Queue)this).end++] = v;}
+    /** Removes the value at the front of the queue. */
+    void delete();
+    /** Removes and returns the value from the front of the queue. */
+    default byte pop() {final byte o = data()[((Queue)this).start]; delete(); return o;}
+    /** @return The value at the front (i.e. least recently pushed value) of the queue. */
+    default byte front() {assert !empty(); return data()[((Queue)this).start];}
+    /** @return The value at the back (i.e. most recently pushed value) of the queue. */
+    default byte back() {assert !empty(); return data()[((Queue)this).end-1];}
+    
+    @Override ByteQueue clone();
+}

src/main/java/azuretriple/primitivecontainer/ByteSet.java

@@ -0,0 +1,37 @@
+package azuretriple.primitivecontainer;
+
+/** A set containing {@code byte}s. */
+public record ByteSet(OrderedByteList data) implements Cloneable
+{
+    /** Creates a copy of the argument. */
+    @SuppressWarnings("CopyConstructorMissesField")
+    public ByteSet(final ByteSet other) {this(new OrderedByteList(other.data));}
+    
+    /**
+     * Adds the value to the set.
+     * @return The index in the backing list where the value was inserted, or the inverted
+     *         index of the existing element if it already exists in the set.
+     */
+    public int add(final byte v)
+    {
+        final int i = data.find(v);
+        if(i >= 0) data.list.insert(i,v);
+        return i;
+    }
+    /**
+     * Removes the value from the set.
+     * @return The index in the backing list where the value was removed, or the inverted
+     *         index where the element would have been removed if it was not in the set.
+     */
+    public int remove(final byte v)
+    {
+        final int i = ~data.find(v);
+        if(i >= 0) data.list.remove(i);
+        return i;
+    }
+    /** @return {@code true} iff the value exists in the set. */
+    public boolean contains(final byte v) {return data.find(v) < 0;}
+    
+    @SuppressWarnings("MethodDoesntCallSuperMethod")
+    @Override public ByteSet clone() {return new ByteSet(this);}
+}