Allow Reader to accept any method of reading bytes.

`bufferHolderReference` can be volatile instead of atomic, since operations like `getAndSet` aren't used.

Author: shawjef3

reader/src/main/java/com/maxmind/db/ByteBufferByteReader.java

@@ -0,0 +1,60 @@
+package com.maxmind.db;
+
+import java.nio.ByteBuffer;
+
+/**
+ * A {@link ByteReader} implemented by a {@link ByteBuffer}.
+ */
+public class ByteBufferByteReader extends IntLimitedByteReader {
+    protected final ByteBuffer bytes;
+
+    /**
+     * Create a {@link ByteReader} from a {@link ByteBuffer}.
+     */
+    public ByteBufferByteReader(final ByteBuffer bytes) {
+        this.bytes = bytes;
+    }
+
+    @Override
+    public byte[] getBytes(final int length) {
+        final byte[] dst = new byte[length];
+        bytes.get(dst);
+        return dst;
+    }
+
+    @Override
+    public byte get() {
+        return bytes.get();
+    }
+
+    @Override
+    public byte get(long index) {
+        return super.get(index);
+    }
+
+    @Override
+    protected byte get(final int index) {
+        return bytes.get(index);
+    }
+
+    @Override
+    public long capacity() {
+        return bytes.capacity();
+    }
+
+    @Override
+    protected ByteReader position(final int newPosition) {
+        bytes.position(newPosition);
+        return this;
+    }
+
+    @Override
+    public long position() {
+        return bytes.position();
+    }
+
+    @Override
+    public ByteReader duplicate() {
+        return new ByteBufferByteReader(bytes.duplicate());
+    }
+}

reader/src/main/java/com/maxmind/db/ByteReader.java

@@ -0,0 +1,57 @@
+package com.maxmind.db;
+
+import java.nio.ByteBuffer;
+
+/**
+ * <p>This provides functionality from {@link ByteBuffer} that is required for this library.
+ * The default implementation is {@link ByteBufferByteReader}, which just redirects method calls
+ * to a {@link ByteBuffer}.Another implementation might be preferable. In that case, you can pass
+ * it to {@link Reader#Reader(ByteReader, String, NodeCache)}.</p>
+ *
+ * <p>Methods in implementations should throw the same exceptions as the methods with the same name
+ * in {@link ByteBuffer}.</p>
+ *
+ * <p>If your implementation can only handle positions of up to <code>Integer.MAX_VALUE</code>,
+ * implement {@link IntLimitedByteReader}.</p>
+ */
+public interface ByteReader {
+
+    /**
+     * See {@link ByteBuffer#position()}
+     */
+    long position();
+
+    /**
+     * See {@link ByteBuffer#position(int)}
+     */
+    ByteReader position(final long newPosition);
+
+    /**
+     * See {@link ByteBuffer#capacity()}.
+     */
+    long capacity();
+
+    /**
+     * Get the byte at {@link ByteReader#position()}. See {@link ByteBuffer#get()}
+     */
+    byte get();
+
+    /**
+     * Get the byte at the given index. See {@link ByteBuffer#get(int)}
+     */
+    byte get(final long index);
+
+    /**
+     * Read the requested number of bytes starting at {@link ByteReader#position()}.
+     * It moves {@link ByteReader#position()} forward by the same amount.
+     */
+    byte[] getBytes(final int length);
+
+    /**
+     * This is intended for creating a copy of this collection that is safe
+     * for use by a new thread.</p>
+     *
+     * See {@link java.nio.ByteBuffer#duplicate()}
+     */
+    ByteReader duplicate();
+}

…in/java/com/maxmind/db/BufferHolder.java …ava/com/maxmind/db/ByteReaderHolder.javareader/src/main/java/com/maxmind/db/BufferHolder.java renamed to reader/src/main/java/com/maxmind/db/ByteReaderHolder.java reader/src/main/java/com/maxmind/db/BufferHolder.java renamed to reader/src/main/java/com/maxmind/db/ByteReaderHolder.java

@@ -10,11 +10,15 @@
 import java.nio.channels.FileChannel;
 import java.nio.channels.FileChannel.MapMode;
 
-final class BufferHolder {
+final class ByteReaderHolder {
     // DO NOT PASS OUTSIDE THIS CLASS. Doing so will remove thread safety.
-    private final ByteBuffer buffer;
+    private final ByteReader reader;
 
-    BufferHolder(File database, FileMode mode) throws IOException {
+    ByteReaderHolder(ByteReader reader) {
+        this.reader = reader;
+    }
+
+    ByteReaderHolder(File database, FileMode mode) throws IOException {
         try (
             final RandomAccessFile file = new RandomAccessFile(database, "r");
             final FileChannel channel = file.getChannel()
@@ -26,21 +30,23 @@ final class BufferHolder {
                         + database.getName()
                         + " into memory. Unexpected end of stream.");
                 }
-                this.buffer = buf.asReadOnlyBuffer();
+                this.reader = new ByteBufferByteReader(buf.asReadOnlyBuffer());
             } else {
-                this.buffer = channel.map(MapMode.READ_ONLY, 0, channel.size()).asReadOnlyBuffer();
+                final ByteBuffer mappedBuffer =
+                    channel.map(MapMode.READ_ONLY, 0, channel.size()).asReadOnlyBuffer();
+                this.reader = new ByteBufferByteReader(mappedBuffer);
             }
         }
     }
 
     /**
-     * Construct a ThreadBuffer from the provided URL.
+     * Construct a {@link ByteReaderHolder} from the provided {@link InputStream}.
      *
      * @param stream the source of my bytes.
      * @throws IOException          if unable to read from your source.
-     * @throws NullPointerException if you provide a NULL InputStream
+     * @throws NullPointerException if you provide a {@code null} InputStream
      */
-    BufferHolder(InputStream stream) throws IOException {
+    ByteReaderHolder(InputStream stream) throws IOException {
         if (null == stream) {
             throw new NullPointerException("Unable to use a NULL InputStream");
         }
@@ -50,14 +56,15 @@ final class BufferHolder {
         while (-1 != (br = stream.read(bytes))) {
             baos.write(bytes, 0, br);
         }
-        this.buffer = ByteBuffer.wrap(baos.toByteArray()).asReadOnlyBuffer();
+        final ByteBuffer readOnlyBuffer = ByteBuffer.wrap(baos.toByteArray()).asReadOnlyBuffer();
+        this.reader = new ByteBufferByteReader(readOnlyBuffer);
     }
 
     /*
      * Returns a duplicate of the underlying ByteBuffer. The returned ByteBuffer
      * should not be shared between threads.
      */
-    ByteBuffer get() {
+    public ByteReader get() {
         // The Java API docs for buffer state:
         //
         //     Buffers are not safe for use by multiple concurrent threads. If a buffer is to be
@@ -75,6 +82,6 @@ ByteBuffer get() {
         // operations on the original buffer object, the risk of not synchronizing this call seems
         // relatively low and worth taking for the performance benefit when lookups are being done
         // from many threads.
-        return this.buffer.duplicate();
+        return reader.duplicate();
     }
 }

reader/src/main/java/com/maxmind/db/CacheKey.java

@@ -8,17 +8,17 @@
  * @param <T> the type of value
  */
 public final class CacheKey<T> {
-    private final int offset;
+    private final long offset;
     private final Class<T> cls;
     private final java.lang.reflect.Type type;
 
-    CacheKey(int offset, Class<T> cls, java.lang.reflect.Type type) {
+    CacheKey(long offset, Class<T> cls, java.lang.reflect.Type type) {
         this.offset = offset;
         this.cls = cls;
         this.type = type;
     }
 
-    int getOffset() {
+    long getOffset() {
         return this.offset;
     }
 
@@ -58,7 +58,7 @@ public boolean equals(Object o) {
 
     @Override
     public int hashCode() {
-        int result = offset;
+        int result = Long.hashCode(offset);
         result = 31 * result + (cls == null ? 0 : cls.hashCode());
         result = 31 * result + (type == null ? 0 : type.hashCode());
         return result;

reader/src/main/java/com/maxmind/db/CtrlData.java

@@ -3,10 +3,10 @@
 final class CtrlData {
     private final Type type;
     private final int ctrlByte;
-    private final int offset;
-    private final int size;
+    private final long offset;
+    private final long size;
 
-    CtrlData(Type type, int ctrlByte, int offset, int size) {
+    CtrlData(Type type, int ctrlByte, long offset, long size) {
         this.type = type;
         this.ctrlByte = ctrlByte;
         this.offset = offset;
@@ -21,11 +21,11 @@ public int getCtrlByte() {
         return this.ctrlByte;
     }
 
-    public int getOffset() {
+    public long getOffset() {
         return this.offset;
     }
 
-    public int getSize() {
+    public long getSize() {
         return this.size;
     }
 }