Add support for floats, doubles and booleans

Author: Pyknic

pom.xml

@@ -24,7 +24,7 @@
     <modelVersion>4.0.0</modelVersion>
     <groupId>com.github.pyknic</groupId>
     <artifactId>immutable-array</artifactId>
-    <version>1.0.0</version>
+    <version>1.0.1</version>
     <packaging>jar</packaging>
 
     <name>Immutable Array</name>

src/main/java/com/github/pyknic/bigarray/BooleanImmutableArray.java

@@ -0,0 +1,96 @@
+/**
+ *
+ * Copyright (c) 2006-2016, Emil Forslund. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); You may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at:
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.github.pyknic.bigarray;
+
+import com.github.pyknic.bigarray.internal.booleans.BooleanImmutableArrayBuilder;
+
+/**
+ * An immutable boolean array that can hold a very large number of elements. 
+ * Implementations of this interface may or may not be backed by a direct buffer 
+ * depending on the size and how the data contained is structured.
+ * <p>
+ * To create a new instance of this interface, use the builder pattern initiated
+ * with the {@link #builder()} method. The actual implementation that is used
+ * will depend on the data that is passed to the builder. After the instance has
+ * been built, it will be immutable.
+ * 
+ * @author Emil Forslund
+ * @since  1.0.1
+ */
+public interface BooleanImmutableArray {
+    
+    /**
+     * Returns the value located at the specified index in the array. If the
+     * index is outside the bounds of the array, the behavior is unspecified.
+     * 
+     * @param index  the index
+     * @return       the value at that index
+     */
+    boolean getAsBoolean(long index);
+    
+    /**
+     * Returns the length of the array (the number of booleans that can safely
+     * be retrieved using the {@link #getAsBoolean(long)} method).
+     * 
+     * @return  the length
+     */
+    long length();
+    
+    /**
+     * Creates a new builder. The builder guarantees that appended values will
+     * be stored in the same order as they were inserted, but the actual size of
+     * the array and how it is backed will be determined when the 
+     * {@link Builder#build()} method is finally invoked.
+     * <p>
+     * The builder should not be used after the {@link Builder#build()}-method
+     * has been called.
+     * 
+     * @return  a new builder
+     */
+    static Builder builder() {
+        return new BooleanImmutableArrayBuilder();
+    }
+    
+    /**
+     * A builder for a {@link BooleanImmutableArray}. The builder can be 
+     * appended with values using the {@link #append(boolean)}-method until it 
+     * is finalized using the {@link #build()}-method. The backing 
+     * implementation will be decided once the array is built.
+     * <p>
+     * The implementation of {@code Builder} is intended to handle a very large
+     * amount of booleans as well as a very small amount.
+     */
+    interface Builder {
+        
+        /**
+         * Append an value to the builder.
+         * 
+         * @param value  the value to append
+         * @return       a reference to this builder
+         */
+        BooleanImmutableArray.Builder append(boolean value);
+    
+        /**
+         * Builds the array. After this method has been called, the builder
+         * should be discarded. The returned array is immutable.
+         * 
+         * @return  the built array
+         */
+        BooleanImmutableArray build();
+        
+    }
+}

src/main/java/com/github/pyknic/bigarray/ByteImmutableArray.java

@@ -16,7 +16,7 @@
  */
 package com.github.pyknic.bigarray;
 
-import com.github.pyknic.bigarray.internal.ByteImmutableArrayBuilder;
+import com.github.pyknic.bigarray.internal.bytes.ByteImmutableArrayBuilder;
 
 /**
  * An immutable byte array that can hold a very large number of elements. 

src/main/java/com/github/pyknic/bigarray/DoubleImmutableArray.java

@@ -0,0 +1,97 @@
+/**
+ *
+ * Copyright (c) 2006-2016, Emil Forslund. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); You may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at:
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.github.pyknic.bigarray;
+
+import com.github.pyknic.bigarray.internal.doubles.DoubleImmutableArrayBuilder;
+
+/**
+ * An immutable double array that can hold a very large number of elements. 
+ * Implementations of this interface may or may not be backed by a direct buffer 
+ * depending on the size and how the data contained is structured.
+ * <p>
+ * To create a new instance of this interface, use the builder pattern initiated
+ * with the {@link #builder()} method. The actual implementation that is used
+ * will depend on the data that is passed to the builder. After the instance has
+ * been built, it will be immutable.
+ * 
+ * @author Emil Forslund
+ * @since  1.0.1
+ */
+public interface DoubleImmutableArray {
+
+    /**
+     * Returns the value located at the specified index in the array. If the
+     * index is outside the bounds of the array, the behavior is unspecified.
+     * 
+     * @param index  the index
+     * @return       the value at that index
+     */
+    double getAsDouble(long index);
+    
+    /**
+     * Returns the length of the array (the number of doubles that can safely
+     * be retrieved using the {@link #getAsDouble(long)} method).
+     * 
+     * @return  the length
+     */
+    long length();
+    
+    /**
+     * Creates a new builder. The builder guarantees that appended values will
+     * be stored in the same order as they were inserted, but the actual size of
+     * the array and how it is backed will be determined when the 
+     * {@link Builder#build()} method is finally invoked.
+     * <p>
+     * The builder should not be used after the {@link Builder#build()}-method
+     * has been called.
+     * 
+     * @return  a new builder
+     */
+    static Builder builder() {
+        return new DoubleImmutableArrayBuilder();
+    }
+    
+    /**
+     * A builder for a {@link DoubleImmutableArray}. The builder can be appended
+     * with values using the {@link #append(double)}-method until it is 
+     * finalized using the {@link #build()}-method. The backing implementation 
+     * will be decided once the array is built.
+     * <p>
+     * The implementation of {@code Builder} is intended to handle a very large
+     * amount of doubles as well as a very small amount.
+     */
+    interface Builder {
+        
+        /**
+         * Append an value to the builder.
+         * 
+         * @param value  the value to append
+         * @return       a reference to this builder
+         */
+        DoubleImmutableArray.Builder append(double value);
+    
+        /**
+         * Builds the array. After this method has been called, the builder
+         * should be discarded. The returned array is immutable.
+         * 
+         * @return  the built array
+         */
+        DoubleImmutableArray build();
+        
+    }
+    
+}

src/main/java/com/github/pyknic/bigarray/FloatImmutableArray.java

@@ -0,0 +1,97 @@
+/**
+ *
+ * Copyright (c) 2006-2016, Emil Forslund. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); You may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at:
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.github.pyknic.bigarray;
+
+import com.github.pyknic.bigarray.internal.floats.FloatImmutableArrayBuilder;
+
+/**
+ * An immutable float array that can hold a very large number of elements. 
+ * Implementations of this interface may or may not be backed by a direct buffer 
+ * depending on the size and how the data contained is structured.
+ * <p>
+ * To create a new instance of this interface, use the builder pattern initiated
+ * with the {@link #builder()} method. The actual implementation that is used
+ * will depend on the data that is passed to the builder. After the instance has
+ * been built, it will be immutable.
+ * 
+ * @author Emil Forslund
+ * @since  1.0.1
+ */
+public interface FloatImmutableArray {
+
+    /**
+     * Returns the value located at the specified index in the array. If the
+     * index is outside the bounds of the array, the behavior is unspecified.
+     * 
+     * @param index  the index
+     * @return       the value at that index
+     */
+    float getAsFloat(long index);
+    
+    /**
+     * Returns the length of the array (the number of floats that can safely
+     * be retrieved using the {@link #getAsFloat(long)} method).
+     * 
+     * @return  the length
+     */
+    long length();
+    
+    /**
+     * Creates a new builder. The builder guarantees that appended values will
+     * be stored in the same order as they were inserted, but the actual size of
+     * the array and how it is backed will be determined when the 
+     * {@link Builder#build()} method is finally invoked.
+     * <p>
+     * The builder should not be used after the {@link Builder#build()}-method
+     * has been called.
+     * 
+     * @return  a new builder
+     */
+    static Builder builder() {
+        return new FloatImmutableArrayBuilder();
+    }
+    
+    /**
+     * A builder for a {@link FloatImmutableArray}. The builder can be appended
+     * with values using the {@link #append(float)}-method until it is finalized
+     * using the {@link #build()}-method. The backing implementation will be
+     * decided once the array is built.
+     * <p>
+     * The implementation of {@code Builder} is intended to handle a very large
+     * amount of floats as well as a very small amount.
+     */
+    interface Builder {
+        
+        /**
+         * Append an value to the builder.
+         * 
+         * @param value  the value to append
+         * @return       a reference to this builder
+         */
+        FloatImmutableArray.Builder append(float value);
+    
+        /**
+         * Builds the array. After this method has been called, the builder
+         * should be discarded. The returned array is immutable.
+         * 
+         * @return  the built array
+         */
+        FloatImmutableArray build();
+        
+    }
+    
+}

src/main/java/com/github/pyknic/bigarray/IntImmutableArray.java

@@ -16,7 +16,7 @@
  */
 package com.github.pyknic.bigarray;
 
-import com.github.pyknic.bigarray.internal.IntImmutableArrayBuilder;
+import com.github.pyknic.bigarray.internal.ints.IntImmutableArrayBuilder;
 
 /**
  * An immutable integer array that can hold a very large number of elements. 

src/main/java/com/github/pyknic/bigarray/LongImmutableArray.java

@@ -16,7 +16,7 @@
  */
 package com.github.pyknic.bigarray;
 
-import com.github.pyknic.bigarray.internal.LongImmutableArrayBuilder;
+import com.github.pyknic.bigarray.internal.longs.LongImmutableArrayBuilder;
 
 /**
  * An immutable long array that can hold a very large number of elements. 

src/main/java/com/github/pyknic/bigarray/ShortImmutableArray.java

@@ -16,7 +16,7 @@
  */
 package com.github.pyknic.bigarray;
 
-import com.github.pyknic.bigarray.internal.ShortImmutableArrayBuilder;
+import com.github.pyknic.bigarray.internal.shorts.ShortImmutableArrayBuilder;
 
 /**
  * An immutable short array that can hold a very large number of elements. 

src/main/java/com/github/pyknic/bigarray/internal/EmptyImmutableArray.java

@@ -16,7 +16,10 @@
  */
 package com.github.pyknic.bigarray.internal;
 
+import com.github.pyknic.bigarray.BooleanImmutableArray;
 import com.github.pyknic.bigarray.ByteImmutableArray;
+import com.github.pyknic.bigarray.DoubleImmutableArray;
+import com.github.pyknic.bigarray.FloatImmutableArray;
 import com.github.pyknic.bigarray.IntImmutableArray;
 import com.github.pyknic.bigarray.LongImmutableArray;
 import com.github.pyknic.bigarray.ShortImmutableArray;
@@ -26,13 +29,16 @@
  * @author Emil Forslund
  * @since  1.0.0
  */
-final class EmptyImmutableArray 
+public final class EmptyImmutableArray 
 implements LongImmutableArray, 
            IntImmutableArray, 
            ShortImmutableArray, 
-           ByteImmutableArray {
+           ByteImmutableArray,
+           FloatImmutableArray,
+           DoubleImmutableArray,
+           BooleanImmutableArray {
 
-    EmptyImmutableArray() {}
+    public EmptyImmutableArray() {}
 
     @Override
     public long getAsLong(long index) {
@@ -53,6 +59,21 @@ public short getAsShort(long index) {
     public byte getAsByte(long index) {
         throw new ArrayIndexOutOfBoundsException();
     }
+    
+    @Override
+    public float getAsFloat(long index) {
+        throw new ArrayIndexOutOfBoundsException();
+    }
+
+    @Override
+    public double getAsDouble(long index) {
+        throw new ArrayIndexOutOfBoundsException();
+    }
+
+    @Override
+    public boolean getAsBoolean(long index) {
+        throw new ArrayIndexOutOfBoundsException();
+    }
 
     @Override
     public long length() {