com.inet.gradle.setup.util

Class ReplacingInputStream

java.lang.Object

java.io.InputStream

java.io.FilterInputStream

com.inet.gradle.setup.util.ReplacingInputStream

All Implemented Interfaces:

java.io.Closeable, java.lang.AutoCloseable

public class ReplacingInputStream
extends java.io.FilterInputStream

Stands for the input stream that decorates given input stream and replaces its content during reading according to the specified rules.

This class applies replacement rules in particular order based on replacement 'from' data length. I.e. if this class is provided with replacements like ({1, 2} -> {3, 4}; {2, 3, 4} -> {5, 6, 7}; {4, 5} -> {7, 8}) it guarantees that '{2, 3, 4} -> {5, 6, 7}' replacement is applied before anothers. Processing order of same 'from'-length replacements is unspecified.

When particular replacement rule is applied, it's 'to' clause is not processed via another replacement rules. I.e. if we have a mappings like '{1, 2, 3} -> {4, 5, 6}' and {5} -> {7}, last rule is not applied to the '5' byte that appeared at the '5, 6, 7' group. Memory overhead This class uses internal buffering similar to the one used by PushbackInputStream and uses a dedicated buffer for single-byte reads (InputStream.read()). I.e. it creates two buffers in addition to the given stream. One buffer has a size that is max of replacements 'from' and 'to' buffers size, another is guaranteed to be not more than size of the buffer used by client for buffered reading (read(byte[], int, int)).

CPU overhead Generally speaking this class matches every read byte against configured replacement rules and performs replacement if necessary.

Not thread-safe.

Example

       Map<byte[], byte[]> replacements = new HashMap<byte[],byte[]>();
       replacements.put(new byte[] {1, 2}, new byte[] {7, 8});
       replacements.put(new byte[] {1}, new byte[] {9});
       replacements.put(new byte[] {3, 2}, new byte[0]);
       byte[] input = {4, 3, 2, 1, 2, 1, 3};
       ReplaceFilterInputStream in = new ReplaceFilterInputStream(new ByteArrayInputStream(input), replacements);
       ByteArrayOutputStream out = new ByteArrayOutputStream();
       int read;
       while ((read = in.read()) >= 0) {
           out.write(read);
       }
       System.out.println(Arrays.toString(out.toByteArray())); // prints [4, 7, 8, 9, 3]
 

Since:

Aug 31, 2009

Field Summary

Fields inherited from class java.io.FilterInputStream

in

Constructor Summary

Constructors

Constructor and Description
ReplacingInputStream(java.io.InputStream in, java.util.Map<byte[],byte[]> replacements) Creates new ReplacementInputStream object.

Method Summary

Modifier and Type	Method and Description
int	read()
int	read(byte[] b, int off, int len)

Methods inherited from class java.io.FilterInputStream

available, close, mark, markSupported, read, reset, skip

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

ReplacingInputStream

public ReplacingInputStream(java.io.InputStream in,
                            java.util.Map<byte[],byte[]> replacements)
                     throws java.lang.IllegalArgumentException

Creates new ReplacementInputStream object.

Parameters:

in - input stream which content should be replaced if necessary

replacements - replacements to use with the given input stream; may be empty map, may not be null

Throws:

java.lang.IllegalArgumentException - if given input stream to process or 'replacements' argument is null

Method Detail

read

public int read()
         throws java.io.IOException

Overrides:

read in class java.io.FilterInputStream

Throws:

java.io.IOException

read

public int read(byte[] b,
                int off,
                int len)
         throws java.io.IOException

Overrides:

read in class java.io.FilterInputStream

Throws:

java.io.IOException