Changeset 13061 in josm for trunk/src/com/drew/lang

Timestamp:

2017-10-30T22:46:09+01:00 (8 years ago)

Author:

Don-vip

Message:

fix #15505 - update to metadata-extractor 2.10.1

Location:

trunk/src/com/drew/lang

Files:

• BufferBoundsException.java (modified) (1 diff)
• ByteArrayReader.java (modified) (7 diffs)
• Charsets.java (added)
• CompoundException.java (modified) (1 diff)
• GeoLocation.java (modified) (1 diff)
• RandomAccessReader.java (modified) (14 diffs)
• Rational.java (modified) (5 diffs)
• SequentialByteArrayReader.java (modified) (6 diffs)
• SequentialReader.java (modified) (8 diffs)
• StreamReader.java (modified) (7 diffs)
• StringUtil.java (modified) (2 diffs)
• annotations/NotNull.java (modified) (1 diff)
• annotations/Nullable.java (modified) (1 diff)
• annotations/SuppressWarnings.java (added)
• annotations/package-info.java (added)
• annotations/package.html (deleted)
• package-info.java (added)
• package.html (deleted)

trunk/src/com/drew/lang/BufferBoundsException.java

@@ -1 +1 @@
 /*
- * Copyright 2002-2016 Drew Noakes
+ * Copyright 2002-2017 Drew Noakes
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");

trunk/src/com/drew/lang/ByteArrayReader.java

@@ -1 +1 @@
 /*
- * Copyright 2002-2016 Drew Noakes
+ * Copyright 2002-2017 Drew Noakes
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");
@@ -22 +22 @@
 package com.drew.lang;
 
+import com.drew.lang.annotations.NotNull;
+
 import java.io.IOException;
-
-import com.drew.lang.annotations.NotNull;
 
 /**
@@ -39 +39 @@
     @NotNull
     private final byte[] _buffer;
+    private final int _baseOffset;
 
+    @SuppressWarnings({ "ConstantConditions" })
+    @com.drew.lang.annotations.SuppressWarnings(value = "EI_EXPOSE_REP2", justification = "Design intent")
     public ByteArrayReader(@NotNull byte[] buffer)
+    {
+        this(buffer, 0);
+    }
+
+    @SuppressWarnings({ "ConstantConditions" })
+    @com.drew.lang.annotations.SuppressWarnings(value = "EI_EXPOSE_REP2", justification = "Design intent")
+    public ByteArrayReader(@NotNull byte[] buffer, int baseOffset)
     {
         if (buffer == null)
             throw new NullPointerException();
+        if (baseOffset < 0)
+            throw new IllegalArgumentException("Must be zero or greater");
 
         _buffer = buffer;
+        _baseOffset = baseOffset;
+    }
+
+    @Override
+    public int toUnshiftedOffset(int localOffset)
+    {
+        return localOffset + _baseOffset;
     }
 
@@ -51 +70 @@
     public long getLength()
     {
-        return _buffer.length;
+        return _buffer.length - _baseOffset;
     }
 
     @Override
-    protected byte getByte(int index) throws IOException
+    public byte getByte(int index) throws IOException
     {
-        return _buffer[index];
+        validateIndex(index, 1);
+        return _buffer[index + _baseOffset];
     }
 
@@ -64 +84 @@
     {
         if (!isValidIndex(index, bytesRequested))
-            throw new BufferBoundsException(index, bytesRequested, _buffer.length);
+            throw new BufferBoundsException(toUnshiftedOffset(index), bytesRequested, _buffer.length);
     }
 
@@ -72 +92 @@
         return bytesRequested >= 0
             && index >= 0
-            && (long)index + (long)bytesRequested - 1L < _buffer.length;
+            && (long)index + (long)bytesRequested - 1L < getLength();
     }
 
@@ -82 +102 @@
 
         byte[] bytes = new byte[count];
-        System.arraycopy(_buffer, index, bytes, 0, count);
+        System.arraycopy(_buffer, index + _baseOffset, bytes, 0, count);
         return bytes;
     }

trunk/src/com/drew/lang/CompoundException.java

@@ -1 +1 @@
 /*
- * Copyright 2002-2016 Drew Noakes
+ * Copyright 2002-2017 Drew Noakes
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");

trunk/src/com/drew/lang/GeoLocation.java

@@ -1 +1 @@
 /*
- * Copyright 2002-2016 Drew Noakes
+ * Copyright 2002-2017 Drew Noakes
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");

trunk/src/com/drew/lang/RandomAccessReader.java

@@ -1 +1 @@
 /*
- * Copyright 2002-2016 Drew Noakes
+ * Copyright 2002-2017 Drew Noakes
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");
@@ -22 +22 @@
 package com.drew.lang;
 
-import com.drew.lang.annotations.NotNull;
-
 import java.io.IOException;
 import java.io.UnsupportedEncodingException;
+import java.nio.charset.Charset;
+
+import com.drew.lang.annotations.NotNull;
+import com.drew.lang.annotations.Nullable;
+import com.drew.metadata.StringValue;
 
 /**
@@ -36 +39 @@
  * <ul>
  *     <li>{@link ByteArrayReader}</li>
- *     <li>{@link RandomAccessStreamReader}</li>
  * </ul>
  *
@@ -45 +47 @@
     private boolean _isMotorolaByteOrder = true;
 
+    public abstract int toUnshiftedOffset(int localOffset);
+
     /**
      * Gets the byte value at the specified byte <code>index</code>.
@@ -57 +61 @@
      * @throws IOException if the byte is unable to be read
      */
-    protected abstract byte getByte(int index) throws IOException;
+    public abstract byte getByte(int index) throws IOException;
 
     /**
@@ -89 +93 @@
      * Returns the length of the data source in bytes.
      * <p>
-     * This is a simple operation for implementations (such as {@link RandomAccessFileReader} and
+     * This is a simple operation for implementations (such as
      * {@link ByteArrayReader}) that have the entire data source available.
      * <p>
-     * Users of this method must be aware that sequentially accessed implementations such as
-     * {@link RandomAccessStreamReader} will have to read and buffer the entire data source in
+     * Users of this method must be aware that sequentially accessed implementations
+     * will have to read and buffer the entire data source in
      * order to determine the length.
      *
@@ -207 +211 @@
         if (_isMotorolaByteOrder) {
             // Motorola - MSB first
-            return (short) (((short)getByte(index    ) << 8 & (short)0xFF00) |
-                            ((short)getByte(index + 1)      & (short)0xFF));
+            return (short) ((getByte(index    ) << 8 & (short)0xFF00) |
+                            (getByte(index + 1)      & (short)0xFF));
         } else {
             // Intel ordering - LSB first
-            return (short) (((short)getByte(index + 1) << 8 & (short)0xFF00) |
-                            ((short)getByte(index    )      & (short)0xFF));
+            return (short) ((getByte(index + 1) << 8 & (short)0xFF00) |
+                            (getByte(index    )      & (short)0xFF));
         }
     }
@@ -229 +233 @@
         if (_isMotorolaByteOrder) {
             // Motorola - MSB first (big endian)
-            return (((int)getByte(index    )) << 16 & 0xFF0000) |
-                   (((int)getByte(index + 1)) << 8  & 0xFF00) |
-                   (((int)getByte(index + 2))       & 0xFF);
+            return ((getByte(index    )) << 16 & 0xFF0000) |
+                   ((getByte(index + 1)) << 8  & 0xFF00) |
+                   ((getByte(index + 2))       & 0xFF);
         } else {
             // Intel ordering - LSB first (little endian)
-            return (((int)getByte(index + 2)) << 16 & 0xFF0000) |
-                   (((int)getByte(index + 1)) << 8  & 0xFF00) |
-                   (((int)getByte(index    ))       & 0xFF);
+            return ((getByte(index + 2)) << 16 & 0xFF0000) |
+                   ((getByte(index + 1)) << 8  & 0xFF00) |
+                   ((getByte(index    ))       & 0xFF);
         }
     }
@@ -256 +260 @@
                    (((long)getByte(index + 1)) << 16 & 0xFF0000L) |
                    (((long)getByte(index + 2)) << 8  & 0xFF00L) |
-                   (((long)getByte(index + 3))       & 0xFFL);
+                   ((getByte(index + 3))       & 0xFFL);
         } else {
             // Intel ordering - LSB first (little endian)
@@ -262 +266 @@
                    (((long)getByte(index + 2)) << 16 & 0xFF0000L) |
                    (((long)getByte(index + 1)) << 8  & 0xFF00L) |
-                   (((long)getByte(index    ))       & 0xFFL);
+                   ((getByte(index    ))       & 0xFFL);
         }
     }
@@ -312 +316 @@
                    ((long)getByte(index + 5) << 16 & 0xFF0000L) |
                    ((long)getByte(index + 6) << 8  & 0xFF00L) |
-                   ((long)getByte(index + 7)       & 0xFFL);
+                   (getByte(index + 7)       & 0xFFL);
         } else {
             // Intel ordering - LSB first
@@ -322 +326 @@
                    ((long)getByte(index + 2) << 16 & 0xFF0000L) |
                    ((long)getByte(index + 1) << 8  & 0xFF00L) |
-                   ((long)getByte(index    )       & 0xFFL);
+                   (getByte(index    )       & 0xFFL);
         }
     }
@@ -365 +369 @@
 
     @NotNull
-    public String getString(int index, int bytesRequested) throws IOException
-    {
-        return new String(getBytes(index, bytesRequested));
-    }
-
-    @NotNull
-    public String getString(int index, int bytesRequested, String charset) throws IOException
+    public StringValue getStringValue(int index, int bytesRequested, @Nullable Charset charset) throws IOException
+    {
+        return new StringValue(getBytes(index, bytesRequested), charset);
+    }
+
+    @NotNull
+    public String getString(int index, int bytesRequested, @NotNull Charset charset) throws IOException
+    {
+        return new String(getBytes(index, bytesRequested), charset.name());
+    }
+
+    @NotNull
+    public String getString(int index, int bytesRequested, @NotNull String charset) throws IOException
     {
         byte[] bytes = getBytes(index, bytesRequested);
@@ -392 +402 @@
      */
     @NotNull
-    public String getNullTerminatedString(int index, int maxLengthBytes) throws IOException
-    {
-        // NOTE currently only really suited to single-byte character strings
-
-        byte[] bytes = getBytes(index, maxLengthBytes);
+    public String getNullTerminatedString(int index, int maxLengthBytes, @NotNull Charset charset) throws IOException
+    {
+        return new String(getNullTerminatedBytes(index, maxLengthBytes), charset.name());
+    }
+
+    @NotNull
+    public StringValue getNullTerminatedStringValue(int index, int maxLengthBytes, @Nullable Charset charset) throws IOException
+    {
+        byte[] bytes = getNullTerminatedBytes(index, maxLengthBytes);
+
+        return new StringValue(bytes, charset);
+    }
+
+    /**
+     * Returns the sequence of bytes punctuated by a <code>\0</code> value.
+     *
+     * @param index The index within the buffer at which to start reading the string.
+     * @param maxLengthBytes The maximum number of bytes to read. If a <code>\0</code> byte is not reached within this limit,
+     * the returned array will be <code>maxLengthBytes</code> long.
+     * @return The read byte array, excluding the null terminator.
+     * @throws IOException The buffer does not contain enough bytes to satisfy this request.
+     */
+    @NotNull
+    public byte[] getNullTerminatedBytes(int index, int maxLengthBytes) throws IOException
+    {
+        byte[] buffer = getBytes(index, maxLengthBytes);
 
         // Count the number of non-null bytes
         int length = 0;
-        while (length < bytes.length && bytes[length] != '\0')
+        while (length < buffer.length && buffer[length] != 0)
             length++;
 
-        return new String(bytes, 0, length);
+        if (length == maxLengthBytes)
+            return buffer;
+
+        byte[] bytes = new byte[length];
+        if (length > 0)
+            System.arraycopy(buffer, 0, bytes, 0, length);
+        return bytes;
     }
 }

trunk/src/com/drew/lang/Rational.java

@@ -1 +1 @@
 /*
- * Copyright 2002-2016 Drew Noakes
+ * Copyright 2002-2017 Drew Noakes
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");
@@ -36 +36 @@
  * @author Drew Noakes https://drewnoakes.com
  */
-public class Rational extends java.lang.Number implements Serializable
+@SuppressWarnings("WeakerAccess")
+public class Rational extends java.lang.Number implements Comparable<Rational>, Serializable
 {
     private static final long serialVersionUID = 510688928138848770L;
@@ -173 +174 @@
                 (_denominator != 0 && (_numerator % _denominator == 0)) ||
                 (_denominator == 0 && _numerator == 0);
+    }
+
+    /** Checks if either the numerator or denominator are zero. */
+    public boolean isZero()
+    {
+        return _numerator == 0 || _denominator == 0;
     }
 
@@ -212 +219 @@
 
     /**
-     * Decides whether a brute-force simplification calculation should be avoided
-     * by comparing the maximum number of possible calculations with some threshold.
-     *
-     * @return true if the simplification should be performed, otherwise false
-     */
-    private boolean tooComplexForSimplification()
-    {
-        double maxPossibleCalculations = (((double) (Math.min(_denominator, _numerator) - 1) / 5d) + 2);
-        final int maxSimplificationCalculations = 1000;
-        return maxPossibleCalculations > maxSimplificationCalculations;
+     * Compares two {@link Rational} instances, returning true if they are mathematically
+     * equivalent (in consistence with {@link Rational#equals(Object)} method).
+     *
+     * @param that the {@link Rational} to compare this instance to.
+     * @return the value {@code 0} if this {@link Rational} is
+     *         equal to the argument {@link Rational} mathematically; a value less
+     *         than {@code 0} if this {@link Rational} is less
+     *         than the argument {@link Rational}; and a value greater
+     *         than {@code 0} if this {@link Rational} is greater than the argument
+     *         {@link Rational}.
+     */
+    public int compareTo(@NotNull Rational that) {
+        return Double.compare(this.doubleValue(), that.doubleValue());
+    }
+
+    /**
+     * Indicates whether this instance and <code>other</code> are numerically equal,
+     * even if their representations differ.
+     *
+     * For example, 1/2 is equal to 10/20 by this method.
+     * Similarly, 1/0 is equal to 100/0 by this method.
+     * To test equal representations, use EqualsExact.
+     *
+     * @param other The rational value to compare with
+     */
+    public boolean equals(Rational other) {
+        return other.doubleValue() == doubleValue();
+    }
+
+    /**
+     * Indicates whether this instance and <code>other</code> have identical
+     * Numerator and Denominator.
+     * <p>
+     * For example, 1/2 is not equal to 10/20 by this method.
+     * Similarly, 1/0 is not equal to 100/0 by this method.
+     * To test numerically equivalence, use Equals(Rational).</p>
+     *
+     * @param other The rational value to compare with
+     */
+    public boolean equalsExact(Rational other) {
+        return getDenominator() == other.getDenominator() && getNumerator() == other.getNumerator();
     }
 
@@ -249 +287 @@
     /**
      * <p>
-     * Simplifies the {@link Rational} number.</p>
+     * Simplifies the representation of this {@link Rational} number.</p>
      * <p>
-     * Prime number series: 1, 2, 3, 5, 7, 9, 11, 13, 17</p>
+     * For example, 5/10 simplifies to 1/2 because both Numerator
+     * and Denominator share a common factor of 5.</p>
      * <p>
-     * To reduce a rational, need to see if both numerator and denominator are divisible
-     * by a common factor.  Using the prime number series in ascending order guarantees
-     * the minimum number of checks required.</p>
-     * <p>
-     * However, generating the prime number series seems to be a hefty task.  Perhaps
-     * it's simpler to check if both d &amp; n are divisible by all numbers from 2 {@literal ->}
-     * (Math.min(denominator, numerator) / 2).  In doing this, one can check for 2
-     * and 5 once, then ignore all even numbers, and all numbers ending in 0 or 5.
-     * This leaves four numbers from every ten to check.</p>
-     * <p>
-     * Therefore, the max number of pairs of modulus divisions required will be:</p>
-     * <pre><code>
-     *    4   Math.min(denominator, numerator) - 1
-     *   -- * ------------------------------------ + 2
-     *   10                    2
-     *
-     *   Math.min(denominator, numerator) - 1
-     * = ------------------------------------ + 2
-     *                  5
-     * </code></pre>
-     *
-     * @return a simplified instance, or if the Rational could not be simplified,
-     *         returns itself (unchanged)
+     * Uses the Euclidean Algorithm to find the greatest common divisor.</p>
+     *
+     * @return A simplified instance if one exists, otherwise a copy of the original value.
      */
     @NotNull
     public Rational getSimplifiedInstance()
     {
-        if (tooComplexForSimplification()) {
-            return this;
+        long gcd = GCD(_numerator, _denominator);
+
+        return new Rational(_numerator / gcd, _denominator / gcd);
+    }
+
+    private static long GCD(long a, long b)
+    {
+        if (a < 0)
+            a = -a;
+        if (b < 0)
+            b = -b;
+
+        while (a != 0 && b != 0)
+        {
+            if (a > b)
+                a %= b;
+            else
+                b %= a;
         }
-        for (int factor = 2; factor <= Math.min(_denominator, _numerator); factor++) {
-            if ((factor % 2 == 0 && factor > 2) || (factor % 5 == 0 && factor > 5)) {
-                continue;
-            }
-            if (_denominator % factor == 0 && _numerator % factor == 0) {
-                // found a common factor
-                return new Rational(_numerator / factor, _denominator / factor);
-            }
-        }
-        return this;
+
+        return a == 0 ? b : a;
     }
 }

trunk/src/com/drew/lang/SequentialByteArrayReader.java

@@ -1 +1 @@
 /*
- * Copyright 2002-2016 Drew Noakes
+ * Copyright 2002-2017 Drew Noakes
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");
@@ -37 +37 @@
     private int _index;
 
+    @Override
+    public long getPosition()
+    {
+        return _index;
+    }
+
     public SequentialByteArrayReader(@NotNull byte[] bytes)
     {
@@ -42 +48 @@
     }
 
+    @SuppressWarnings("ConstantConditions")
     public SequentialByteArrayReader(@NotNull byte[] bytes, int baseIndex)
     {
@@ -52 +59 @@
 
     @Override
-    protected byte getByte() throws IOException
+    public byte getByte() throws IOException
     {
         if (_index >= _bytes.length) {
@@ -73 +80 @@
 
         return bytes;
+    }
+
+    @Override
+    public void getBytes(@NotNull byte[] buffer, int offset, int count) throws IOException
+    {
+        if (_index + count > _bytes.length) {
+            throw new EOFException("End of data reached.");
+        }
+
+        System.arraycopy(_bytes, _index, buffer, offset, count);
+        _index += count;
     }
 
@@ -105 +123 @@
         return true;
     }
+
+    @Override
+    public int available() {
+        return _bytes.length - _index;
+    }
 }

trunk/src/com/drew/lang/SequentialReader.java

@@ -1 +1 @@
 /*
- * Copyright 2002-2016 Drew Noakes
+ * Copyright 2002-2017 Drew Noakes
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");
@@ -23 +23 @@
 
 import com.drew.lang.annotations.NotNull;
+import com.drew.lang.annotations.Nullable;
+import com.drew.metadata.StringValue;
 
 import java.io.EOFException;
 import java.io.IOException;
 import java.io.UnsupportedEncodingException;
+import java.nio.charset.Charset;
 
 /**
  * @author Drew Noakes https://drewnoakes.com
  */
+@SuppressWarnings("WeakerAccess")
 public abstract class SequentialReader
 {
@@ -37 +41 @@
     private boolean _isMotorolaByteOrder = true;
 
+    public abstract long getPosition() throws IOException;
+
     /**
      * Gets the next byte in the sequence.
@@ -42 +48 @@
      * @return The read byte value
      */
-    protected abstract byte getByte() throws IOException;
+    public abstract byte getByte() throws IOException;
 
     /**
@@ -52 +58 @@
     @NotNull
     public abstract byte[] getBytes(int count) throws IOException;
+
+    /**
+     * Retrieves bytes, writing them into a caller-provided buffer.
+     * @param buffer The array to write bytes to.
+     * @param offset The starting position within buffer to write to.
+     * @param count The number of bytes to be written.
+     */
+    public abstract void getBytes(@NotNull byte[] buffer, int offset, int count) throws IOException;
 
     /**
@@ -70 +84 @@
      */
     public abstract boolean trySkip(long n) throws IOException;
+
+    /**
+     * Returns an estimate of the number of bytes that can be read (or skipped
+     * over) from this {@link SequentialReader} without blocking by the next
+     * invocation of a method for this input stream. A single read or skip of
+     * this many bytes will not block, but may read or skip fewer bytes.
+     * <p>
+     * Note that while some implementations of {@link SequentialReader} like
+     * {@link SequentialByteArrayReader} will return the total remaining number
+     * of bytes in the stream, others will not. It is never correct to use the
+     * return value of this method to allocate a buffer intended to hold all
+     * data in this stream.
+     *
+     * @return an estimate of the number of bytes that can be read (or skipped
+     *         over) from this {@link SequentialReader} without blocking or
+     *         {@code 0} when it reaches the end of the input stream.
+     */
+    public abstract int available();
 
     /**
@@ -284 +316 @@
     }
 
+    @NotNull
+    public String getString(int bytesRequested, @NotNull Charset charset) throws IOException
+    {
+        byte[] bytes = getBytes(bytesRequested);
+        return new String(bytes, charset);
+    }
+
+    @NotNull
+    public StringValue getStringValue(int bytesRequested, @Nullable Charset charset) throws IOException
+    {
+        return new StringValue(getBytes(bytesRequested), charset);
+    }
+
     /**
      * Creates a String from the stream, ending where <code>byte=='\0'</code> or where <code>length==maxLength</code>.
@@ -293 +338 @@
      */
     @NotNull
-    public String getNullTerminatedString(int maxLengthBytes) throws IOException
-    {
-        // NOTE currently only really suited to single-byte character strings
-
-        byte[] bytes = new byte[maxLengthBytes];
+    public String getNullTerminatedString(int maxLengthBytes, Charset charset) throws IOException
+    {
+       return getNullTerminatedStringValue(maxLengthBytes, charset).toString();
+    }
+
+    /**
+     * Creates a String from the stream, ending where <code>byte=='\0'</code> or where <code>length==maxLength</code>.
+     *
+     * @param maxLengthBytes The maximum number of bytes to read.  If a <code>\0</code> byte is not reached within this limit,
+     *                       reading will stop and the string will be truncated to this length.
+     * @param charset The <code>Charset</code> to register with the returned <code>StringValue</code>, or <code>null</code> if the encoding
+     *                is unknown
+     * @return The read string.
+     * @throws IOException The buffer does not contain enough bytes to satisfy this request.
+     */
+    @NotNull
+    public StringValue getNullTerminatedStringValue(int maxLengthBytes, Charset charset) throws IOException
+    {
+        byte[] bytes = getNullTerminatedBytes(maxLengthBytes);
+
+        return new StringValue(bytes, charset);
+    }
+
+    /**
+     * Returns the sequence of bytes punctuated by a <code>\0</code> value.
+     *
+     * @param maxLengthBytes The maximum number of bytes to read. If a <code>\0</code> byte is not reached within this limit,
+     * the returned array will be <code>maxLengthBytes</code> long.
+     * @return The read byte array, excluding the null terminator.
+     * @throws IOException The buffer does not contain enough bytes to satisfy this request.
+     */
+    @NotNull
+    public byte[] getNullTerminatedBytes(int maxLengthBytes) throws IOException
+    {
+        byte[] buffer = new byte[maxLengthBytes];
 
         // Count the number of non-null bytes
         int length = 0;
-        while (length < bytes.length && (bytes[length] = getByte()) != '\0')
+        while (length < buffer.length && (buffer[length] = getByte()) != 0)
             length++;
 
-        return new String(bytes, 0, length);
+        if (length == maxLengthBytes)
+            return buffer;
+
+        byte[] bytes = new byte[length];
+        if (length > 0)
+            System.arraycopy(buffer, 0, bytes, 0, length);
+        return bytes;
     }
 }

trunk/src/com/drew/lang/StreamReader.java

@@ -1 +1 @@
 /*
- * Copyright 2002-2016 Drew Noakes
+ * Copyright 2002-2017 Drew Noakes
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");
@@ -37 +37 @@
     private final InputStream _stream;
 
+    private long _pos;
+
+    @Override
+    public long getPosition()
+    {
+        return _pos;
+    }
+
+    @SuppressWarnings("ConstantConditions")
     public StreamReader(@NotNull InputStream stream)
     {
@@ -43 +52 @@
 
         _stream = stream;
+        _pos = 0;
     }
 
     @Override
-    protected byte getByte() throws IOException
+    public byte getByte() throws IOException
     {
         int value = _stream.read();
         if (value == -1)
             throw new EOFException("End of data reached.");
+        _pos++;
         return (byte)value;
     }
@@ -59 +70 @@
     {
         byte[] bytes = new byte[count];
+        getBytes(bytes, 0, count);
+        return bytes;
+    }
+
+    @Override
+    public void getBytes(@NotNull byte[] buffer, int offset, int count) throws IOException
+    {
         int totalBytesRead = 0;
-
-        while (totalBytesRead != count) {
-            final int bytesRead = _stream.read(bytes, totalBytesRead, count - totalBytesRead);
+        while (totalBytesRead != count)
+        {
+            final int bytesRead = _stream.read(buffer, offset + totalBytesRead, count - totalBytesRead);
             if (bytesRead == -1)
                 throw new EOFException("End of data reached.");
@@ -68 +86 @@
             assert(totalBytesRead <= count);
         }
-
-        return bytes;
+        _pos += totalBytesRead;
     }
 
@@ -93 +110 @@
     }
 
+    @Override
+    public int available() {
+        try {
+            return _stream.available();
+        } catch (IOException e) {
+            return 0;
+        }
+    }
+
     private long skipInternal(long n) throws IOException
     {
@@ -109 +135 @@
                 break;
         }
+        _pos += skippedTotal;
         return skippedTotal;
     }

trunk/src/com/drew/lang/StringUtil.java

@@ -1 +1 @@
 /*
- * Copyright 2002-2016 Drew Noakes
+ * Copyright 2002-2017 Drew Noakes
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");
@@ -34 +34 @@
  * @author Drew Noakes https://drewnoakes.com
  */
-public class StringUtil
+public final class StringUtil
 {
     @NotNull

trunk/src/com/drew/lang/annotations/NotNull.java

@@ -1 +1 @@
 /*
- * Copyright 2002-2016 Drew Noakes
+ * Copyright 2002-2017 Drew Noakes
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");

trunk/src/com/drew/lang/annotations/Nullable.java

@@ -1 +1 @@
 /*
- * Copyright 2002-2016 Drew Noakes
+ * Copyright 2002-2017 Drew Noakes
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");