---

InputStream.java

Go to the documentation of this file.

/**************************************************************************
 Copyright (c) 2000-2001, Tony Garnock-Jones
 All rights reserved.

 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are
 met:

     * Redistributions of source code must retain the above copyright
       notice, this list of conditions and the following disclaimer.

     * Redistributions in binary form must reproduce the above
       copyright notice, this list of conditions and the following
       disclaimer in the documentation and/or other materials provided
       with the distribution.

     * Neither the names of the copyright holders nor the names of this
       software's contributors may be used to endorse or promote
       products derived from this software without specific prior
       written permission.

 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR
 CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
**************************************************************************/

package org.hebe.mps;

import java.io.*;
import java.net.*;

/**
 * Structures the bitstream coming from an MPS server into usable MPS
 * primitive types (mapped onto Java types, of course). Uses a
 * Connection object to talk to the other end.
 *
 * @author Tony Garnock-Jones <tonyg@kcbbs.gen.nz>
 * @see org.hebe.mps.Connection
 * @see org.hebe.mps.OutputStream
 */
public class InputStream {
    private Connection connection;
    private java.io.InputStream input;

    /**
     * Construct an InputStream which decodes the bits coming from a
     * Connection object.
     *
     * @param c the raw connection to filter
     */
    public InputStream(Connection c) {
        connection = c;
        input = null;
    }

    /**
     * Construct an InputStream which decodes bits from an arbitrary
     * inputstream.
     *
     * @param i the raw inputstream to filter
     */
    public InputStream(java.io.InputStream i) {
        connection = null;
        input = i;
    }

    /**
     * Reads a single byte from the server.
     *
     * @return the byte read
     * @exception IOException if there's an error reading our input
     * @exception MPSConnectionClosedException if the connection closes unexpectedly
     */
    private int read() throws IOException, MPSException {
        int result = input.read();
        if (result < 0)
            throw new MPSConnectionClosedException("while reading");
        //System.out.println("Read: " + result);
        return result;
    }

    /**
     * Causes the connection to the server to open, if it isn't
     * already open.
     *
     * @exception MPSException from connection.getInputStream() if there's a problem
     * @see org.hebe.mps.Connection#getInputStream
     */
    private void open() throws MPSException {
        if (input == null)
            input = connection.getInputStream();
    }

    /**
     * Reads a single <i>int</i> from the server.
     *
     * @return the 32-bit signed value read from our input
     * @exception MPSException if there's a problem reading
     */
    public int readint() throws MPSException {
        try {
            int result = 0;
            open();
            result = result | read();
            result = (result << 8) | read();
            result = (result << 8) | read();
            result = (result << 8) | read();
            return result;
        } catch (IOException e) {
            throw new MPSException("Error reading an int from remote end");
        }
    }

    /**
     * Reads a single <i>java.lang.String</i> from the server.
     *
     * @return the string read
     * @see java.lang.String
     * @exception MPSException if there's a problem reading
     */
    public String readstring() throws MPSException {
        StringBuffer result = new StringBuffer();

        try {
            char ch;

            open();
            while (true) {
                ch = (char) read();
                if (ch == 0)
                    break;

                result.append(ch);
            }
        } catch (IOException e) {
            throw new MPSException("Error reading a string from remote end");
        }

        return result.toString();
    }

    /**
     * Reads a single <i>boolean</i> from the server.
     *
     * @return the boolean read
     * @exception MPSException if there's a problem reading
     */
    public boolean readbool() throws MPSException {
        try {
            open();
            return (read() != 0);
        } catch (IOException e) {
            throw new MPSException("Error reading a bool from remote end");
        }
    }

    /**
     * Reads a single 64-bit <i>long</i> from the server.
     *
     * @return the long read
     * @exception MPSException if there's a problem reading
     */
    public long readlong() throws MPSException {
        try {
            long result = 0;
            open();
            result = result | read();
            result = (result << 8) | read();
            result = (result << 8) | read();
            result = (result << 8) | read();
            result = (result << 8) | read();
            result = (result << 8) | read();
            result = (result << 8) | read();
            result = (result << 8) | read();
            return result;
        } catch (IOException e) {
            throw new MPSException("Error reading a long from remote end");
        }
    }

    /**
     * Reads a single <i>char</i> from the server.
     *
     * @return the char read
     * @exception MPSException if there's a problem reading
     */
    public char readchar() throws MPSException {
        try {
            open();
            return (char) read();
        } catch (IOException e) {
            throw new MPSException("Error reading a char from remote end");
        }
    }

    /**
     * Reads the canonical (bound) name of an MPS object from the
     * remote end of the link.
     *
     * @return the canonical name of the object read from the server
     * @exception MPSException if there's a problem reading
     * @see org.hebe.mps.OutputStream#writeReference
     */
    public String readReference() throws MPSException {
        return readstring();
    }

    /**
     * Reads a single <i>float</i> from the server.
     *
     * @return the float read
     * @exception MPSException if there's a problem reading
     */
    public float readfloat() throws MPSException {
        open();
        return Float.intBitsToFloat(readint());
    }
}

---