core: Opaque: Add support for mutable byte arrays

Similar to mutable ByteBuffers, provide support for mutable byte[]
backing Opaque.

Related: #149
Signed-off-by: Christian Kohlschütter <[email protected]>

Author: kohlschuetter

core/src/main/java/org/dcache/nfs/util/Opaque.java

@@ -43,6 +43,19 @@ static Opaque forBytes(byte[] bytes) {
         return new OpaqueImpl(bytes.clone());
     }
 
+    /**
+     * Returns an mutable {@link Opaque} instance based on the given byte array.
+     * <p>
+     * Note that the returned {@link Opaque} is typically not suitable for <em>storing</em> in a
+     * {@link java.util.HashMap}, but merely for lookups. Call {@link #toImmutableOpaque()} when necessary.
+     * 
+     * @param bytes The bytes.
+     * @return The {@link Opaque} instance.
+     */
+    static Opaque forMutableByteArray(byte[] bytes) {
+        return new OpaqueMutableImpl(bytes);
+    }
+
     /**
      * Returns an immutable {@link Opaque} instance based on a copy of the {@code length} bytes from the given
      * {@link ByteBuffer}.
@@ -161,12 +174,12 @@ default void putBytes(ByteBuffer buf) {
     @Override
     boolean equals(Object o);
 
-    final class OpaqueImpl implements Opaque {
-        private final byte[] _opaque;
+    class OpaqueImpl implements Opaque {
+        final byte[] _opaque;
         private String base64 = null;
         private int hashCode;
 
-        private OpaqueImpl(byte[] opaque) {
+        OpaqueImpl(byte[] opaque) {
             _opaque = opaque;
         }
 
@@ -175,10 +188,14 @@ public byte[] toBytes() {
             return _opaque.clone();
         }
 
+        protected String toBase64Impl() {
+            return Base64.getEncoder().withoutPadding().encodeToString(_opaque);
+        }
+
         @Override
         public String toBase64() {
             if (base64 == null) {
-                base64 = Base64.getEncoder().withoutPadding().encodeToString(_opaque);
+                base64 = toBase64Impl();
             }
             return base64;
         }
@@ -246,6 +263,28 @@ public Opaque toImmutableOpaque() {
         }
     }
 
+    final class OpaqueMutableImpl extends OpaqueImpl {
+        protected OpaqueMutableImpl(byte[] opaque) {
+            super(opaque);
+        }
+
+        @Override
+        public Opaque toImmutableOpaque() {
+            return Opaque.forBytes(_opaque);
+        }
+
+        @Override
+        public String toBase64() {
+            return toBase64Impl();
+        }
+
+        @Override
+        public int hashCode() {
+            return Arrays.hashCode(_opaque);
+        }
+
+    }
+
     final class OpaqueBufferImpl implements Opaque {
         private final ByteBuffer buf;
         private final int index;

core/src/test/java/org/dcache/nfs/util/OpaqueTest.java

@@ -9,7 +9,7 @@
 
 public class OpaqueTest {
     @Test
-    public void testMutable() {
+    public void testMutableByteBuffer() {
         ByteBuffer buf = ByteBuffer.allocate(64);
         buf.putInt(3, 0xAABBCCDD);
         buf.putInt(7, 0xEEFF0011);
@@ -37,4 +37,23 @@ public void testMutable() {
         assertNotEquals(bytesOpaque, bufOpaque);
         assertNotEquals(bytesOpaque.hashCode(), bufOpaque.hashCode());
     }
+
+    @Test
+    public void testMutableByteArray() throws Exception {
+        byte[] buf = new byte[] {(byte) 0x01, (byte) 0x02, (byte) 0x03, (byte) 0x04};
+        Opaque bufOpaque = Opaque.forMutableByteArray(buf);
+        Opaque bytesOpaque = Opaque.forBytes(new byte[] {(byte) 0x01, (byte) 0x02, (byte) 0x03, (byte) 0x04});
+
+        assertEquals(bufOpaque.toBase64(), bytesOpaque.toBase64());
+        assertEquals(bufOpaque, bytesOpaque);
+        assertEquals(bytesOpaque, bufOpaque);
+        assertEquals(bytesOpaque.hashCode(), bufOpaque.hashCode());
+
+        // change contents of mutable buffer
+        buf[3] = (byte) 0xDD;
+        assertNotEquals(bufOpaque.toBase64(), bytesOpaque.toBase64());
+        assertNotEquals(bufOpaque, bytesOpaque);
+        assertNotEquals(bytesOpaque, bufOpaque);
+        assertNotEquals(bytesOpaque.hashCode(), bufOpaque.hashCode());
+    }
 }