// This example is from the book _Java in a Nutshell_ by David Flanagan.
// Written by David Flanagan.  Copyright (c) 1996 O'Reilly & Associates.
// You may study, use, modify, and distribute this example for any purpose.
// This example is provided WITHOUT WARRANTY either expressed or implied.

import java.io.*;

// This interface defines the methods that the source of data for a pipe
// must define.  These methods are used to allow the source to easily be
// connected to a sink.  
// Note that a PipeSource is Runnable--it is a thread body.
interface PipeSource extends Runnable {
    abstract PipedOutputStream getPipedOutputStream();
    abstract void connectOutputTo(PipeSink sink) throws IOException;
    abstract PipeSink getSink();
    abstract void start();
}

// This interface defines the methods required for a sink of data from
// a pipe.  The methods are used when connecting a source to the sink.
// A PipeSink is also Runnable.
interface PipeSink extends Runnable {
    abstract PipedInputStream getPipedInputStream();
    abstract void connectInputTo(PipeSource source) throws IOException;
}

// A filter in a pipe behaves like both a source of data and a sink of data.
interface PipeFilter extends PipeSource, PipeSink {
};

// This is an implementation of the PipeSource interface that uses an
// InputStream as the source of data.  It creates a PipedOutputStream
// to write the data to.  The run() method copies data from the stream
// to the pipe.
class StreamPipeSource implements PipeSource {
    protected PipedOutputStream out = new PipedOutputStream();
    protected InputStream in;
    protected PipeSink sink;
    
    public StreamPipeSource(InputStream in) { this.in = in; }
    public PipedOutputStream getPipedOutputStream() { return out; }
    public PipeSink getSink() { return sink; }
    public void connectOutputTo(PipeSink sink) throws IOException {
        this.sink = sink;
        out.connect(sink.getPipedInputStream());
        sink.connectInputTo(this);
    }
    
    public void start() {
        // Start ourselves
        new Thread(this).start();
        
        // If our output is a filter, then call its start() method.
        // otherwise, just start our sink
        if (sink instanceof PipeFilter) ((PipeFilter)sink).start();
        else new Thread(sink).start();
    }
    
    public void run() {
        byte[] buffer = new byte[512];
        int bytes_read;
        try { 
            for(;;) {
                bytes_read = in.read(buffer);
                if (bytes_read == -1) { return; }
                out.write(buffer, 0, bytes_read);
            }
        } 
        catch (IOException e) {
            if (e instanceof EOFException) return;
            else System.out.println(e);
        }
        finally { try {out.close();} catch (IOException e) {;} }
    }
}

// This is an implementation of the PipeSink interface that uses an output
// stream as the source of data.  It creates a PipedInputStream to read
// data from the pipe.  The run() method reads data from that pipe and 
// writes it to the output stream (which might be a file or System.out, e.g.)
class StreamPipeSink implements PipeSink {
    protected PipedInputStream in = new PipedInputStream();
    protected OutputStream out;
    
    public StreamPipeSink(OutputStream out) {
        this.out = out;
    }
    
    public PipedInputStream getPipedInputStream() { return in; }
    public void connectInputTo(PipeSource source) throws IOException {
        in.connect(source.getPipedOutputStream());
    }
    
    public void run() {
        byte[] buffer = new byte[512];
        int bytes_read;
        try { 
            for(;;) {
                bytes_read = in.read(buffer);
                if (bytes_read == -1) return;
                out.write(buffer, 0, bytes_read);
            }
        } 
        catch (IOException e) {
            if (e instanceof EOFException) return;
            else System.out.println(e);
        }
        finally { try {in.close();} catch (IOException e) {;} }
    }
}

// This is an abstract implementation of the PipeFilter interface.
// It creates both a PipedInputStream to read from and a PipedOutputStream
// to write to.  The abstract method filter() needs to be defined by
// a subclass to read data from one pipe, filter it, and write the filtered
// data to the other pipe.
abstract class BasicPipeFilter implements PipeFilter {
    protected PipedInputStream in = new PipedInputStream();
    protected PipedOutputStream out = new PipedOutputStream();
    protected PipeSink sink;
    public PipedInputStream getPipedInputStream() { return in; }
    public PipedOutputStream getPipedOutputStream() { return out; }
    
    public void connectOutputTo(PipeSink sink) throws IOException {
        this.sink = sink;
        out.connect(sink.getPipedInputStream());
        sink.connectInputTo((PipeSource) this);
    }
    
    public void start() {
        // Start ourselves
        new Thread(this).start();
        
        // If our output is a filter, then call its start() method.
        // otherwise, just start our sink
        if (sink instanceof PipeFilter) ((PipeFilter)sink).start();
        else new Thread(sink).start();
    }
    
    public PipeSink getSink() { return sink; }
    
    public void connectInputTo(PipeSource source) throws IOException {
        in.connect(source.getPipedOutputStream());
    }
    
    public void run() {
        try { filter(); }
        catch (IOException e) {
            if (e instanceof EOFException) return;
            else System.out.println(e);
        }
        finally {
            try { out.close(); in.close(); } 
            catch (IOException e) { ; }
        }
    }
    
    abstract public void filter() throws IOException;
}

// This is a non-abstract implementation of the PipeFilter interface.
// It uses the GrepInputStream we defined elsewhere to do the filtering.
class GrepFilter extends BasicPipeFilter {
    protected GrepInputStream gis;
    protected PrintStream pout = new PrintStream(out);
    
    public GrepFilter(String pattern) {
        gis = new GrepInputStream(new DataInputStream(in), pattern);
    }
    
    public void filter() throws IOException {
        String line;
        for(;;) {
            line = gis.readLine();
            if (line == null) return;
            pout.println(line);
        }
    }
}

// This is another implementation fo PipeFilter.  It implements the
// trival rot13 cypher on the letters A-Z and a-z.
class Rot13Filter extends BasicPipeFilter {
    public void filter() throws IOException {
        byte[] buffer = new byte[512];
        int bytes_read;
        
        for(;;) {
            bytes_read = in.read(buffer);
            if (bytes_read == -1) return;
            for(int i = 0; i < bytes_read; i++) {
                if ((buffer[i] >= 'a') && (buffer[i] <= 'z')) {
                    buffer[i] = (byte) ('a' + ((buffer[i]-'a') + 13) % 26);
                }
                if ((buffer[i] >= 'A') && (buffer[i] <= 'Z')) {
                    buffer[i] = (byte) ('A' + ((buffer[i]-'A') + 13) % 26);
                }
            }
            out.write(buffer, 0, bytes_read);
        }
    }
}

// This class demonstrates how you might use these pipe classes.
// It is another implementation of a Unix-like grep command.
// Note that it frivolously passes the output of the grep pipe through two
// rot13 pipes (which, combined, leave the output unchanged).
// With the source, filter, and sink infrastructure defined above, it
// is easy to define new filters and create pipes to perform many useful 
// operations.  Other filter possibilities include sorting lines, removing
// duplicate lines, and doing search-and-replace.
public class Pipes {
    public static void main(String[] args) throws IOException {
        if (args.length != 2) {
            System.out.println("Usage: java Pipes <pattern> <filename>");
            System.exit(0);
        }

        // Create a source, three filters, and a sink for the pipe.
        PipeSource source = 
            new StreamPipeSource(new FileInputStream(args[1]));
        PipeFilter filter = new GrepFilter(args[0]);
        PipeFilter filter2 = new Rot13Filter();
        PipeFilter filter3 = new Rot13Filter();
        PipeSink sink = new StreamPipeSink(System.out);

        // Connect them all up.
        source.connectOutputTo(filter);
        filter.connectOutputTo(filter2);
        filter2.connectOutputTo(filter3);
        filter3.connectOutputTo(sink);

        // And start their threads running.
        source.start();
    }
}