CJDBCOutputStream.java

/**
 * C-JDBC: Clustered JDBC.
 * Copyright (C) 2002-2005 French National Institute For Research In Computer
 * Science And Control (INRIA).
 * Contact: c-jdbc@objectweb.org
 * 
 * This library is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as published by the
 * Free Software Foundation; either version 2.1 of the License, or any later
 * version.
 * 
 * This library is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
 * for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
 *
 * Initial developer(s): Nicolas Modrzyk
 * Contributor(s): Emmanuel Cecchet.
 */

package org.objectweb.cjdbc.common.stream;

import java.io.BufferedOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.io.StreamCorruptedException;
import java.net.Socket;
import java.util.ArrayList;

/**
 * ObjectOutputStream to use between the controller and the driver.
 * 
 * @see org.objectweb.cjdbc.common.stream.CJDBCStream
 * @author <a href="mailto:Nicolas.Modrzyk@inrialpes.fr">Nicolas Modrzyk </a>
 * @author <a href="mailto:Emmanuel.Cecchet@inria.fr">Emmanuel Cecchet </a>
 */
public class CJDBCOutputStream
{
  private ObjectOutputStream output;
  private long               bytesWritten;
  private Socket             socket;
  private boolean            useCompression                    = false;
  private long               speed                             = -1;
  private long               dateCreated;
  /**
   * ObjectOutputStream.writeUTF() encodes the String into binary however it
   * only works if the encoded UTF string is shorter in length that a short
   * (0xFFFFL). As every character is encoded in the worst case on 3 bytes, we
   * take this worst case value. If a String.length*3 > 0xFFFFL then we have to
   * go through the standard writeObject (or writeUnshared) method that will
   * call writeString() that will call in turn writeLongUTF(). Unfortunately,
   * writeString and writeLongUTF are not publicly accessible.
   */
  private static final long  MAXIMUM_STRING_LENGTH_IN_WRITEUTF = 0xFFFFL / 3;

  //private int unshared = 0;

  /**
   * Creates a new <code>CJDBCOutputStream</code> object for statistics on
   * sockets
   * 
   * @param socket socket to monitor
   * @throws IOException if an IO error occurs
   * @throws StreamCorruptedException if an error occurs
   */
  public CJDBCOutputStream(Socket socket) throws IOException,
      StreamCorruptedException
  {
    this(socket.getOutputStream());
    this.socket = socket;
  }

  /**
   * Creates a new CJDBCOutputStream from the given input stream.
   * 
   * @param out outputstream to wrap
   * @throws IOException if <code>new ObjectInputStream()</code> throws
   *           anException
   * @throws StreamCorruptedException same as above
   */
  public CJDBCOutputStream(OutputStream out) throws IOException,
      StreamCorruptedException
  {
    output = new ObjectOutputStream(new BufferedOutputStream(out));
    dateCreated = System.currentTimeMillis();
    bytesWritten = 0;
  }

  /**
   * @see java.io.ObjectOutputStream#flush()
   * @throws IOException if an error occurs
   */
  public void flush() throws IOException
  {
    output.flush();
  }

  /**
   * @see java.io.ObjectOutputStream#close()
   * @throws IOException if an error occurs
   */
  public void close() throws IOException
  {
    output.close();
  }

  /**
   * @see java.io.ObjectOutputStream#writeObject(java.lang.Object)
   * @param obj an Object to write to the stream
   * @throws IOException if an error occurs
   */
  public void writeObject(Object obj) throws IOException
  {
    if (useCompression)
    {
      byte[] bytes = CJDBCStream.compressObject(obj);
      bytesWritten += bytes.length + 4;
      // we are sending an integer on the pipe.

      output.writeInt(bytes.length);
      output.write(bytes);
    }
    else
    {
      if (obj == null)
      {
        output.writeInt(CJDBCStream.NULL);
        return;
      }
      else if (obj instanceof String)
      {
        String str = (String) obj;
        if (str.length() < MAXIMUM_STRING_LENGTH_IN_WRITEUTF)
        { // If the String can fit for a writeUTF call then use it else defaults
          // to writeUnshared (below) that will call the appropriate method to
          // send longer strings (not publicly available in the API).
          output.writeInt(CJDBCStream.STRING_OBJECT);
          output.writeUTF(str);
          return;
        }
      }
      else if (obj instanceof Integer)
      {
        output.writeInt(CJDBCStream.INTEGER_OBJECT);
        output.writeInt(((Integer) obj).intValue());
        return;
      }
      else if (obj instanceof Long)
      {
        output.writeInt(CJDBCStream.LONG_OBJECT);
        output.writeLong(((Long) obj).longValue());
        return;
      }
      else if (obj instanceof Boolean)
      {
        output.writeInt(CJDBCStream.BOOLEAN_OBJECT);
        output.writeBoolean(((Boolean) obj).booleanValue());
        return;
      }

      // Here we have an object for which we don't have special optimization and
      // that we will send as an object
      output.writeInt(CJDBCStream.OBJECT);

      // Use the unshared version to prevent the stream to keep references on
      // objects. This prevents objects sent through the channel from being
      // garbage collected and results in memory leaks.
      output.writeUnshared(obj);

      if (obj instanceof ArrayList)
      { // Reset the stream for shallow copies since unshared does not handle
        // them.
        output.flush();
        output.reset();
      }
    }

  }

  /**
   * @see java.io.ObjectOutputStream#writeUTF(java.lang.String)
   * @param string a String to write in UTF form to the stream
   * @throws IOException if an error occurs
   */
  public void writeUTF(String string) throws IOException
  {
    // Let writeObject handle this in case string is null
    this.writeObject(string);
    if (string != null)
      bytesWritten += string.length();
  }

  /**
   * @see java.io.ObjectOutputStream#writeInt(int)
   * @param value an int value to write to the stream
   * @throws IOException if an error occurs
   */
  public void writeInt(int value) throws IOException
  {
    bytesWritten += 4;
    output.writeInt(value);
  }

  /**
   * @see java.io.ObjectOutputStream#writeLong(long)
   * @param value a long value to write to the stream
   * @throws IOException if an error occurs
   */
  public void writeLong(long value) throws IOException
  {
    bytesWritten += 8;
    output.writeLong(value);
  }

  /**
   * @see java.io.ObjectOutputStream#writeBoolean(boolean)
   * @param value a boolean value to write to the stream
   * @throws IOException if an error occurs
   */
  public void writeBoolean(boolean value) throws IOException
  {
    bytesWritten += 1;
    output.writeBoolean(value);
  }

  /**
   * @return Returns the bytesWritten.
   */
  public long getBytesWritten()
  {
    return bytesWritten;
  }

  /**
   * @return Returns the socket.
   */
  public Socket getSocket()
  {
    return socket;
  }

  /**
   * @return Returns the dateCreated.
   */
  public long getDateCreated()
  {
    return dateCreated;
  }

  /**
   * @return Returns the useCompression.
   */
  public boolean getUseCompression()
  {
    return useCompression;
  }

  /**
   * @return Returns the speed.
   */
  public long getSpeed()
  {
    return speed;
  }
}

---