Added CountingReader and LimitAppendable

Author: robtimus

src/main/java/com/github/robtimus/obfuscation/support/CountingReader.java

@@ -0,0 +1,103 @@
+/*
+ * CountingReader.java
+ * Copyright 2022 Rob Spoor
+ *
+ * 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.robtimus.obfuscation.support;
+
+import java.io.IOException;
+import java.io.Reader;
+import java.util.Objects;
+
+/**
+ * A {@link Reader} that counts the number of characters that are read.
+ *
+ * @author Rob Spoor
+ * @since 1.4
+ */
+public class CountingReader extends Reader {
+
+    private final Reader reader;
+
+    private long count;
+    private long mark;
+
+    CountingReader(Reader reader) {
+        this.reader = Objects.requireNonNull(reader);
+        this.count = 0;
+        this.mark = 0;
+    }
+
+    /**
+     * Returns the number of characters read so far. It also includes the number of skipped characters.
+     *
+     * @return The number of characters read or skipped so far.
+     */
+    public long count() {
+        return count;
+    }
+
+    @Override
+    public int read() throws IOException {
+        int result = reader.read();
+        if (result != -1) {
+            count++;
+        }
+        return result;
+    }
+
+    @Override
+    public int read(char[] cbuf, int off, int len) throws IOException {
+        int result = reader.read(cbuf, off, len);
+        if (result != -1) {
+            count += result;
+        }
+        return result;
+    }
+
+    @Override
+    public long skip(long n) throws IOException {
+        long result = reader.skip(n);
+        count += result;
+        return result;
+    }
+
+    @Override
+    public boolean ready() throws IOException {
+        return reader.ready();
+    }
+
+    @Override
+    public boolean markSupported() {
+        return reader.markSupported();
+    }
+
+    @Override
+    public void mark(int readAheadLimit) throws IOException {
+        reader.mark(readAheadLimit);
+        mark = count;
+    }
+
+    @Override
+    public void reset() throws IOException {
+        reader.reset();
+        count = mark;
+    }
+
+    @Override
+    public void close() throws IOException {
+        reader.close();
+    }
+}

src/main/java/com/github/robtimus/obfuscation/support/LimitAppendable.java

@@ -0,0 +1,102 @@
+/*
+ * LimitAppendable.java
+ * Copyright 2022 Rob Spoor
+ *
+ * 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.robtimus.obfuscation.support;
+
+import java.io.IOException;
+
+/**
+ * An {@link Appendable} that limits the amount of text that can be appended.
+ *
+ * @author Rob Spoor
+ * @since 1.4
+ */
+public class LimitAppendable implements Appendable {
+
+    private final Appendable appendable;
+
+    private long remaining;
+
+    LimitAppendable(Appendable appendable, long limit) {
+        this.appendable = appendable;
+        this.remaining = limit;
+    }
+
+    /**
+     * Returns whether or not the limit has been reached.
+     *
+     * @return {@code true} if the limit has been reached, or {@code false} otherwise.
+     */
+    public boolean limitReached() {
+        return remaining <= 0;
+    }
+
+    /**
+     * Returns whether or not the limit has been exceeded. The difference between this method and {@link #limitReached()} is that this method will
+     * return {@code false} if the total length that was appended exactly matches the limit, and {@link #limitReached()} will return {@code true}.
+     *
+     * @return {@code true} if the limit has been exceeded, or {@code false} otherwise.
+     */
+    public boolean limitExceeded() {
+        return remaining == -1;
+    }
+
+    @Override
+    public Appendable append(CharSequence csq) throws IOException {
+        if (remaining > 0) {
+            CharSequence cs = csq != null ? csq : "null"; //$NON-NLS-1$
+            int length = cs.length();
+            if (remaining >= length) {
+                appendable.append(csq);
+                remaining -= length;
+            } else {
+                appendable.append(csq, 0, (int) remaining);
+                remaining = -1;
+            }
+        } else {
+            remaining = -1;
+        }
+        return this;
+    }
+
+    @Override
+    public Appendable append(CharSequence csq, int start, int end) throws IOException {
+        if (remaining > 0) {
+            if (remaining >= end - start) {
+                appendable.append(csq, start, end);
+                remaining -= end - start;
+            } else {
+                appendable.append(csq, start, start + (int) remaining);
+                remaining = -1;
+            }
+        } else {
+            remaining = -1;
+        }
+        return this;
+    }
+
+    @Override
+    public Appendable append(char c) throws IOException {
+        if (remaining > 0) {
+            appendable.append(c);
+            remaining--;
+        } else {
+            remaining = -1;
+        }
+        return this;
+    }
+}

src/main/java/com/github/robtimus/obfuscation/support/ObfuscatorUtils.java

@@ -320,6 +320,20 @@ public static Writer writer(Appendable appendable) {
         return appendable instanceof Writer ? (Writer) appendable : new AppendableWriter(appendable);
     }
 
+    /**
+     * Returns a {@code Reader} that counts all text read from another {@code Reader}.
+     *
+     * @param input The {@code Reader} to read from.
+     * @return A {@code Reader} that counts all text read from the given {@code Reader}.
+     * @throws NullPointerException If the given {@code Reader} is {@code null}.
+     * @since 1.4
+     */
+    @SuppressWarnings("resource")
+    public static CountingReader counting(Reader input) {
+        Objects.requireNonNull(input);
+        return new CountingReader(input);
+    }
+
     /**
      * Returns a {@code Reader} that transparently appends all text read from another {@code Reader} to an {@code Appendable}.
      * If the returned {@code Reader} is closed, the given {@code Reader} will be closed as well. The {@code Appendable} will not be closed though.
@@ -355,6 +369,26 @@ public static Reader readAtMost(Reader input, int limit) {
         return new LimitReader(input, limit);
     }
 
+    // Appendable
+
+    /**
+     * Returns an {@code Appendable} that will discard text after a specific amount of text has been appended.
+     *
+     * @param appendable The {@code Appendable} to append to.
+     * @param limit The maximum number of characters to append to the given {@code Appendable}.
+     * @return An {@code Appendable} that will discard text after a specific amount of text has been appended.
+     * @throws NullPointerException If the given {@code Appendable} is {@code null}.
+     * @throws IllegalArgumentException If the given limit is negative.
+     * @since 1.4
+     */
+    public static LimitAppendable appendAtMost(Appendable appendable, long limit) {
+        Objects.requireNonNull(appendable);
+        if (limit < 0) {
+            throw new IllegalArgumentException(limit + " < 0"); //$NON-NLS-1$
+        }
+        return new LimitAppendable(appendable, limit);
+    }
+
     // I/O
 
     /**
@@ -449,6 +483,8 @@ private static void copyAll(Reader input, Writer destination, char[] buffer) thr
         }
     }
 
+    // masking
+
     /**
      * Copies the contents of a {@code Reader} to an {@code Appendable}, masking each character.
      *
@@ -503,6 +539,8 @@ private static void maskAll(Reader input, Writer destination, char[] buffer, cha
         }
     }
 
+    // appending
+
     /**
      * Appends a single character to an {@code Appendable}.
      * The character to be written is contained in the 16 low-order bits of the given integer value; the 16 high-order bits are ignored.