/home/ythoma/docs/math2mat/svn/wp1/framework/m2mGUI/src/m2m/backend/verifpga/BinaryIn.java

Go to the documentation of this file.

/*************************************************************************
 *  Compilation:  javac BinaryIn.java
 *  Execution:    java BinaryIn input output
 *  
 *  This library is for reading binary data from an input stream.
 *
 *  % java BinaryIn http://www.cs.princeton.edu/introcs/cover.jpg output.jpg
 *  
 *  Copyright © 2000–2010, Robert Sedgewick and Kevin Wayne. 
*       Last updated: Wed Feb 17 14:34:37 EST 2010.
 *
 *************************************************************************/
package m2m.backend.verifpga;

import java.net.URLConnection;
import java.net.URL;
import java.net.Socket;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.FileInputStream;
import java.io.BufferedInputStream;



public final class BinaryIn {
    private BufferedInputStream in;  // the input stream
    private final int EOF = -1;      // end of file
    private int buffer;              // one character buffer
    private int N;                   // number of bits left in buffer

    private void fillBuffer() {
        try {
                buffer = in.read();
                //System.out.println("fillBuffer: " + buffer);  
                N = 8; 
        }
        catch (IOException e) { System.err.println("EOF"); buffer = EOF; N = -1; }
    }

    public BinaryIn() {
        in = new BufferedInputStream(System.in);
        fillBuffer();
    }

    public BinaryIn(InputStream is) {
        in = new BufferedInputStream(is);
        fillBuffer();
    }

    public BinaryIn(Socket socket) {
        try {
            InputStream is = socket.getInputStream();
            in = new BufferedInputStream(is);
            //fillBuffer();
        }
        catch (IOException ioe) {
            System.err.println("Could not open " + socket);
        }
        System.out.println("BinaryIn...");
    }

    public BinaryIn(URL url) {
        try {
            URLConnection site = url.openConnection();
            InputStream is     = site.getInputStream();
            in = new BufferedInputStream(is);
            fillBuffer();
        }
        catch (IOException ioe) {
            System.err.println("Could not open " + url);
        }
    }

    public BinaryIn(String s) {

        try {
            // first try to read file from local file system
            File file = new File(s);
            if (file.exists()) {
                FileInputStream fis = new FileInputStream(file);
                in = new BufferedInputStream(fis);
                fillBuffer();
                return;
            }

            // next try for files included in jar
            URL url = getClass().getResource(s);

            // or URL from web
            if (url == null) { url = new URL(s); }

            URLConnection site = url.openConnection();
            InputStream is     = site.getInputStream();
            in = new BufferedInputStream(is);
            fillBuffer();
        }
        catch (IOException ioe) {
            System.err.println("Could not open " + s);
        }
    }

    public boolean exists()  {
        return in != null;
    }


    public boolean isEmpty() {
        return buffer == EOF;
    }

    public boolean readBoolean() {
        if (isEmpty()) throw new RuntimeException("Reading from empty input stream");
        N--;
        boolean bit = ((buffer >> N) & 1) == 1;
        if (N == 0) fillBuffer();
        return bit;
    }

    public char readChar() {
        if (isEmpty()) throw new RuntimeException("Reading from empty input stream");

        // special case when aligned byte
        if (N == 8) {
            int x = buffer;
            fillBuffer();
            return (char) (x & 0xff);
        }

        // combine last N bits of current buffer with first 8-N bits of new buffer
        int x = buffer;
        x <<= (8-N);
        int oldN = N;
        fillBuffer();
        if (isEmpty()) throw new RuntimeException("Reading from empty input stream");
        N = oldN;
        x |= (buffer >>> N);
        return (char) (x & 0xff);
        // the above code doesn't quite work for the last character if N = 8
        // because buffer will be -1
    }


    public char readChar(int r) {
        if (r < 1 || r > 16) throw new RuntimeException("Illegal value of r = " + r);

        // optimize r = 8 case
        if (r == 8) return readChar();

        char x = 0;
        for (int i = 0; i < r; i++) {
            x <<= 1;
            boolean bit = readBoolean();
            if (bit) x |= 1;
        }
        return x;
    }


    public String readString() {
        if (isEmpty()) throw new RuntimeException("Reading from empty input stream");

        StringBuilder sb = new StringBuilder();
        while (!isEmpty()) {
            char c = readChar();
            sb.append(c);
        }
        return sb.toString();
    }


    public short readShort() {
        short x = 0;
        for (int i = 0; i < 2; i++) {
            char c = readChar();
            x <<= 8;
            x |= c;
        }
        return x;
    }

     public int readInt() {
         int x = 0;
         for (int i = 0; i < 4; i++) {
             char c = readChar();
             x <<= 8;
             x |= c;
         }
         return x;
     }

      public int readIntOther() {
          int x = 0;
          for (int i = 0; i < 4; i++) {
              char c = readChar();
              int y=c;
              for(int j=1;j<i;j++)
                  y <<= 8;
              x |= y;
          }
          return x;
      }

    public int readInt(int r) {
        if (r < 1 || r > 32) throw new RuntimeException("Illegal value of r = " + r);

        // optimize r = 32 case
        if (r == 32) return readInt();

        int x = 0;
        for (int i = 0; i < r; i++) {
            x <<= 1;
            boolean bit = readBoolean();
            if (bit) x |= 1;
        }
        return x;
    }

    public long readLong() {
        long x = 0;
        for (int i = 0; i < 8; i++) {
            char c = readChar();
            x <<= 8;
            x |= c;
        }
        return x;
    }

    public double readDouble() {
        return Double.longBitsToDouble(readLong());
    }

    public float readFloat() {
        return Float.intBitsToFloat(readInt());
    }


    public byte readByte() {
        char c = readChar();
        byte x = (byte) (c & 0xff);
        return x;
    }
    
}