Merge branch 'feat-subtypes'

Author: patrickfav

src/main/java/at/favre/lib/bytes/AbstractBytes.java

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2017 Patrick Favre-Bulle
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 at.favre.lib.bytes;
+
+/**
+ * Base interface for bytes
+ */
+public interface AbstractBytes {
+
+    /**
+     * Checks if instance is mutable
+     *
+     * @return true if mutable, ie. transformers will change internal array
+     */
+    boolean isMutable();
+
+    /**
+     * Checks if instance is readonly
+     *
+     * @return true if readonly, ie. no direct access to the internal array
+     */
+    boolean isReadOnly();
+}

src/main/java/at/favre/lib/bytes/Bytes.java

@@ -56,7 +56,7 @@
  * </pre>
  */
 @SuppressWarnings("WeakerAccess")
-public class Bytes implements Comparable<Bytes> {
+public class Bytes implements Comparable<Bytes>, AbstractBytes {
 
     /* FACTORY ***************************************************************************************************/
 
@@ -93,7 +93,7 @@ public static Bytes allocate(int length, byte defaultValue) {
      * @return new instance
      */
     public static Bytes wrap(Bytes bytes) {
-        return new Bytes(bytes.internalArray(), bytes.byteOrder, bytes.mutable, bytes.readonly);
+        return new Bytes(bytes.internalArray(), bytes.byteOrder);
     }
 
     /**
@@ -381,42 +381,22 @@ public static Bytes random(int length, Random random) {
 
     private final byte[] byteArray;
     private final ByteOrder byteOrder;
-    private final boolean mutable;
-    private final boolean readonly;
+    private final BytesFactory factory;
 
-    /**
-     * Creates a new immutable instance
-     *
-     * @param byteArray internal byte array
-     * @param byteOrder the internal byte order - this is used to interpret given array, not to change it
-     */
     Bytes(byte[] byteArray, ByteOrder byteOrder) {
-        this(byteArray, byteOrder, false, false);
-    }
-
-    /**
-     * Creates a new instance with given array and copies all attributes from old instance
-     *
-     * @param byteArray   internal byte array
-     * @param oldInstance old instance to copy all internal attributes
-     */
-    Bytes(byte[] byteArray, Bytes oldInstance) {
-        this(byteArray, oldInstance.byteOrder(), oldInstance.mutable, oldInstance.readonly);
+        this(byteArray, byteOrder, new Factory());
     }
 
     /**
-     * Creates a new instance
+     * Creates a new immutable instance
      *
      * @param byteArray internal byte array
      * @param byteOrder the internal byte order - this is used to interpret given array, not to change it
-     * @param mutable   if the internal state can be changed
-     * @param readonly  if all getter for internal byte array will fail
      */
-    Bytes(byte[] byteArray, ByteOrder byteOrder, boolean mutable, boolean readonly) {
+    Bytes(byte[] byteArray, ByteOrder byteOrder, BytesFactory factory) {
         this.byteArray = byteArray;
         this.byteOrder = byteOrder;
-        this.mutable = mutable;
-        this.readonly = readonly;
+        this.factory = factory;
     }
 
     /* TRANSFORMER **********************************************************************************************/
@@ -606,7 +586,7 @@ public Bytes rightShift(int shiftCount) {
      * @return copied instance
      */
     public Bytes copy() {
-        return new Bytes(Arrays.copyOf(internalArray(), length()), byteOrder, mutable, readonly);
+        return transform(new BytesTransformer.CopyTransformer(0, length()));
     }
 
     /**
@@ -617,9 +597,7 @@ public Bytes copy() {
      * @return copied instance
      */
     public Bytes copy(int offset, int length) {
-        byte[] copy = new byte[length];
-        System.arraycopy(internalArray(), offset, copy, 0, copy.length);
-        return new Bytes(copy, byteOrder, mutable, readonly);
+        return transform(new BytesTransformer.CopyTransformer(offset, length));
     }
 
     /**
@@ -679,22 +657,6 @@ public Bytes shuffle() {
         return transform(new BytesTransformer.ShuffleTransformer(new SecureRandom()));
     }
 
-    /**
-     * Generic transformation of this instance.
-     * <p>
-     * This transformation might be done in-place (ie. without copying the internal array and overwriting its old state),
-     * or on a copy of the internal data, depending on the type (e.g. {@link MutableBytes}) and if the operation can be done
-     * in-place. Therefore the caller has to ensure that certain side-effects, which occur due to the changing of the internal
-     * data, do not create bugs in his/her code. Usually immutability is prefered, but when handling many or big byte arrays,
-     * mutability enables drastically better performance.
-     *
-     * @param transformer used to transform this instance
-     * @return the transformed instance (might be the same, or a new one)
-     */
-    public Bytes transform(BytesTransformer transformer) {
-        return transformer.transform(this, mutable);
-    }
-
     /**
      * Copies the specified array, truncating or padding with zeros (if necessary)
      * so the copy has the specified length.  For all indices that are
@@ -709,28 +671,24 @@ public Bytes transform(BytesTransformer transformer) {
      * @return a copy with the desired size or "this" instance if newByteLength == current length
      */
     public Bytes resize(int newByteLength) {
-        if (length() == newByteLength) {
-            return this;
-        }
-
-        if (newByteLength < 0) {
-            throw new IllegalArgumentException("cannot resize to smaller than 0");
-        }
-
-        if (newByteLength == 0) {
-            return new Bytes(new byte[0], this);
-        }
-
-        byte[] resizedArray = new byte[newByteLength];
-        if (newByteLength > length()) {
-            System.arraycopy(internalArray(), 0, resizedArray, Math.max(0, Math.abs(newByteLength - length())), Math.min(newByteLength, length()));
-        } else {
-            System.arraycopy(internalArray(), Math.max(0, Math.abs(newByteLength - length())), resizedArray, Math.min(0, Math.abs(newByteLength - length())), Math.min(newByteLength, length()));
-        }
-
-        return new Bytes(resizedArray, this);
+        return transform(new BytesTransformer.ResizeTransformer(newByteLength));
     }
 
+    /**
+     * Generic transformation of this instance.
+     * <p>
+     * This transformation might be done in-place (ie. without copying the internal array and overwriting its old state),
+     * or on a copy of the internal data, depending on the type (e.g. {@link MutableBytes}) and if the operation can be done
+     * in-place. Therefore the caller has to ensure that certain side-effects, which occur due to the changing of the internal
+     * data, do not create bugs in his/her code. Usually immutability is prefered, but when handling many or big byte arrays,
+     * mutability enables drastically better performance.
+     *
+     * @param transformer used to transform this instance
+     * @return the transformed instance (might be the same, or a new one)
+     */
+    public Bytes transform(BytesTransformer transformer) {
+        return factory.wrap(transformer.transform(internalArray(), isMutable()), byteOrder);
+    }
 
     /* ATTRIBUTES ************************************************************************************************/
 
@@ -771,13 +729,24 @@ public ByteOrder byteOrder() {
         return byteOrder;
     }
 
+    /**
+     * Checks if instance is mutable
+     *
+     * @return true if mutable, ie. transformers will change internal array
+     */
+    @Override
+    public boolean isMutable() {
+        return false;
+    }
+
     /**
      * Check if this instance is read only
      *
      * @return true if read only
      */
+    @Override
     public boolean isReadOnly() {
-        return readonly;
+        return false;
     }
 
     /**
@@ -877,10 +846,9 @@ public double entropy() {
      * @return new instance backed by the same data
      */
     public Bytes duplicate() {
-        return wrap(this);
+        return factory.wrap(internalArray(), byteOrder);
     }
 
-
     /**
      * Set the byte order or endianness of this instance. Default in Java is {@link ByteOrder#BIG_ENDIAN}.
      * <p>
@@ -892,7 +860,7 @@ public Bytes duplicate() {
      */
     public Bytes byteOrder(ByteOrder byteOrder) {
         if (byteOrder != this.byteOrder) {
-            return new Bytes(internalArray(), byteOrder, mutable, readonly);
+            return wrap(internalArray(), byteOrder);
         }
         return this;
     }
@@ -903,11 +871,11 @@ public Bytes byteOrder(ByteOrder byteOrder) {
      *
      * @return a new instance if not already readonly, or "this" otherwise
      */
-    public Bytes readOnly() {
-        if (readonly) {
-            return this;
+    public ReadOnlyBytes readOnly() {
+        if (isReadOnly()) {
+            return (ReadOnlyBytes) this;
         } else {
-            return new Bytes(internalArray(), byteOrder, false, true);
+            return new ReadOnlyBytes(internalArray(), byteOrder);
         }
     }
 
@@ -940,7 +908,7 @@ private ByteBuffer internalBuffer() {
      */
     public BigInteger bigInteger() {
         if (byteOrder == ByteOrder.LITTLE_ENDIAN) {
-            return new BigInteger(new BytesTransformer.ReverseTransformer().transform(this, false).array());
+            return new BigInteger(new BytesTransformer.ReverseTransformer().transform(array(), false));
         } else {
             return new BigInteger(array());
         }
@@ -967,7 +935,7 @@ public MutableBytes mutable() {
      * @return new input stream
      */
     public InputStream inputStream() {
-        return new ByteArrayInputStream(internalArray());
+        return new ByteArrayInputStream(array());
     }
 
     /**
@@ -980,10 +948,7 @@ public InputStream inputStream() {
      * @throws ReadOnlyBufferException if this is a read-only instance
      */
     public byte[] array() {
-        if (!readonly) {
-            return internalArray();
-        }
-        throw new ReadOnlyBufferException();
+        return internalArray();
     }
 
     byte[] internalArray() {
@@ -1241,8 +1206,6 @@ public boolean equals(Object o) {
 
         Bytes bytes = (Bytes) o;
 
-        if (mutable != bytes.mutable) return false;
-        if (readonly != bytes.readonly) return false;
         if (!Arrays.equals(byteArray, bytes.byteArray)) return false;
         return byteOrder != null ? byteOrder.equals(bytes.byteOrder) : bytes.byteOrder == null;
     }
@@ -1271,8 +1234,6 @@ public boolean equalsContent(byte[] array) {
     public int hashCode() {
         int result = Arrays.hashCode(byteArray);
         result = 31 * result + (byteOrder != null ? byteOrder.hashCode() : 0);
-        result = 31 * result + (mutable ? 1 : 0);
-        result = 31 * result + (readonly ? 1 : 0);
         return result;
     }
 
@@ -1296,4 +1257,11 @@ public String toString() {
         return length() + " bytes " + preview;
     }
 
+    private static class Factory implements BytesFactory {
+        @Override
+        public Bytes wrap(byte[] array, ByteOrder byteOrder) {
+            return new Bytes(array, byteOrder);
+        }
+    }
+
 }

src/main/java/at/favre/lib/bytes/BytesFactory.java

@@ -0,0 +1,28 @@
+/*
+ * Copyright 2017 Patrick Favre-Bulle
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 at.favre.lib.bytes;
+
+import java.nio.ByteOrder;
+
+public interface BytesFactory {
+    Bytes wrap(byte[] array, ByteOrder byteOrder);
+}