---

OutputStream.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.*;

/**
 * Flattens the bitstream going to an MPS server from MPS primitive
 * types. 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.InputStream
 */
public class OutputStream {
    private Connection connection;
    private java.io.OutputStream output;
    private StringBuffer buffer;

    /**
     * Construct an OutputStream which encodes the bits going to a
     * Connection object.
     *
     * @param c the raw connection to use
     */
    public OutputStream(Connection c) {
        connection = c;
        output = null;
        setupBuffer();
    }

    /**
     * Creates and initialises a fresh StringBuffer in member variable buffer.
     */
    private void setupBuffer() {
        buffer = new StringBuffer();
    }

        /**
         * Resets our internal buffer to empty. */
        public void resetBuffer() {
                setupBuffer();
        }

    /**
     * Construct an OutputStream which sends bits to an arbitrary
     * inputstream.
     *
     * @param o the raw outputstream to use
     */
    public OutputStream(java.io.OutputStream o) {
        connection = null;
        output = o;
        setupBuffer();
    }

    /**
     * Buffer up a single byte to send. The buffer is not flushed to
     * the server until the flush() method is called.
     *
     * @param ch the byte to buffer up
     * @see org.hebe.mps.OutputStream#flush
     */
    private void write(int ch) {
        //System.out.println("Write: " + ch);
        buffer.append((char) ch);

        /*
        byte[] ba = buffer.toString().getBytes();
        for (int i = 0; i < ba.length; i++) {
            System.out.print((int) ba[i]);
            System.out.print(" ");
        }
        System.out.println(""); */
    }

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

    /**
     * Writes a single <i>int</i> to the server.
     *
     * @param i the 32-bit signed value to write
     */
    public void writeint(int i) {
        write((i >> 24) & 255);
        write((i >> 16) & 255);
        write((i >> 8) & 255);
        write(i & 255);
    }

    /**
     * Writes a single <i>java.lang.String</i> to the server.
     *
     * @param s the string to write
     */
    public void writestring(String s) {
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (c == 0)
                break;
            write(c);
        }
        write(0);
    }

    /**
     * Writes a single <i>boolean</i> to the server.
     *
     * @param b the boolean to write
     */
    public void writebool(boolean b) {
        write(b ? 1 : 0);
    }

    /**
     * Writes a single <i>long</i> to the server.
     *
     * @param i the long to write
     */
    public void writelong(long i) {
        write((int) (i >> 56) & 255);
        write((int) (i >> 48) & 255);
        write((int) (i >> 40) & 255);
        write((int) (i >> 32) & 255);
        write((int) (i >> 24) & 255);
        write((int) (i >> 16) & 255);
        write((int) (i >> 8) & 255);
        write((int) i & 255);
    }

    /**
     * Writes a single <i>char</i> to the server.
     *
     * @param ch the char to write
     */
    public void writechar(char ch) {
        write(ch);
    }

    /**
     * Writes a reference to an MPS object to the remote end. Sends a
     * canonical name for the object as a string. The remote end will
     * then construct a proxy on the other side of the connection to
     * make use of the reference that has been sent to it.
     *
     * @param o the MPS Interface to write
     * @exception MPSException if there's a problem writing
     * @exception MPSException if <code>o</code> is not being
     * served by an instance of Server and <code>o</code> is not an
     * instance of <code>Proxy</code>
     *
     * @see org.hebe.mps.Proxy
     * @see org.hebe.mps.InputStream#readReference
     */
    public void writeReference(Object o) throws MPSException {
        Server svr = Server.serverFor(o);

        if (svr == null) {
          // No local server for this object. Perhaps we're a Proxy
          // for some remote object?
          try {
            Proxy p = (Proxy) o;
            writestring(p.getReference());
          } catch (ClassCastException cce) {
            // Nope.
            throw new MPSException("Cannot write reference to unserved, non-Proxy object");
          }
        } else {
          // We have a local server. Send one of its addresses over
          // the link.
          writestring(svr.getBoundName());
        }
    }

    /**
     * Writes a single <i>float</i> to the server.
     *
     * @param f the float to write
     * @exception MPSException if there's a problem writing
     */
    public void writefloat(float f) throws MPSException {
        writeint(Float.floatToIntBits(f));
    }

    /**
     * Sends the total accumulated buffer of bytes over the
     * connection. Empties the buffer ready for the next batch of
     * bytes.
     *
     * @exception MPSException if there's a problem writing.
     */
    public void flush() throws MPSException {
        if (buffer.length() > 0) {
            try {
                //System.out.println("Flushing OutputStream...");
                open();
                output.write(buffer.toString().getBytes());
                setupBuffer();
            } catch (IOException ioe) {
                throw new MPSException("Error flushing OutputStream buffer");
            }
        }
    }
}

---