/* 

 * Copyright 1998-1999 Sun Microsystems, Inc.  All Rights Reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code 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 General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 */

/*

 */

import java.io.*;

import java.rmi.server.*;

import java.net.*;

public class Compress {

    interface CompressConstants {

	// constants for 6-bit code values

	static final int NOP  = 0;	// no operation: used to pad words on flush()

	static final int RAW  = 1;	// introduces raw byte format

	static final int BASE = 2;	// base for codes found in lookup table

	static final String codeTable =

	    "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ ,.!?\"'()";

    }

    public static class CompressRMIClientSocketFactory 

	implements java.rmi.server.RMIClientSocketFactory, Serializable {

	public Socket createSocket(String host, int port) 

	    throws IOException {

	    return ((Socket) new CompressSocket(host, port));

	}

    }

    public static class CompressRMIServerSocketFactory 

	implements RMIServerSocketFactory, 

		   Serializable {

	public ServerSocket createServerSocket(int port) 

	    throws IOException {

	    return ((ServerSocket) new CompressServerSocket(port));

	}

    }

    public static class CompressSocket extends Socket {

	private InputStream in;

	private OutputStream out;

	public CompressSocket() { super(); }

	public CompressSocket(String host, int port) throws IOException {

	    super(host, port);

	}

	public InputStream getInputStream() throws IOException {

	    if (in == null) {

		in = new CompressInputStream(super.getInputStream());

	    }

	    return in;

        }

	public OutputStream getOutputStream() throws IOException {

	    if (out == null) {

		out = new CompressOutputStream(super.getOutputStream());

	    }

	    return out;

	}

    }

    public static class CompressServerSocket extends ServerSocket {

	public CompressServerSocket(int port) throws IOException {

	    super(port);

	}

	public Socket accept() throws IOException {

	    Socket s = new CompressSocket();

	    implAccept(s);

	    return s;

	}

    }

    public static class CompressInputStream extends FilterInputStream

	implements CompressConstants

    {

	public CompressInputStream(InputStream in) {

	    super(in);

	}

	// buffer of unpacked 6-bit codes from last 32-word read

	int buf[] = new int[5];

	// position of next code to read in buffer (5 == end of buffer)

	int bufPos = 5;

	public int read() throws IOException {

	    try {

		int code;

		do {

		    code = readCode();

		} while (code == NOP);	// ignore NOP codes

		if (code >= BASE)

		    return codeTable.charAt(code - BASE);

		else if (code == RAW) {

		    int high = readCode();

		    int low = readCode();

		    return (high << 4) | low;

		} else

		    throw new IOException("unknown compression code: " + code);

	    } catch (EOFException e) {

		return -1;

	    }

	}

	public int read(byte b[], int off, int len) throws IOException {

	    if (len <= 0) {

		return 0;

	    }

	    int c = read();

	    if (c == -1) {

		return -1;

	    }

	    b[off] = (byte)c;

	    int i = 1;

	    /*****

		  try {

		  for (; i < len ; i++) {

		  c = read();

		  if (c == -1) {

		  break;

		  }

		  if (b != null) {

		  b[off + i] = (byte)c;

		  }

		  }

		  } catch (IOException ee) {

		  }

	    *****/

	    return i;

	}

	private int readCode() throws IOException {

	    if (bufPos == 5) {

		int b1 = in.read();

		int b2 = in.read();

		int b3 = in.read();

		int b4 = in.read();

		if ((b1 | b2 | b3 | b4) < 0)

		    throw new EOFException();

		int pack = (b1 << 24) | (b2 << 16) | (b3 << 8) | b4;

		buf[0] = (pack >>> 24) & 0x3F;

		buf[1] = (pack >>> 18) & 0x3F;

		buf[2] = (pack >>> 12) & 0x3F;

		buf[3] = (pack >>>  6) & 0x3F;

		buf[4] = (pack >>>  0) & 0x3F;

		bufPos = 0;

	    }

	    return buf[bufPos++];

	}

    }

    public static class CompressOutputStream extends FilterOutputStream

	implements CompressConstants

    {

	public CompressOutputStream(OutputStream out) {

	    super(out);

	}

	// buffer of 6-bit codes to pack into next 32-bit word

	int buf[] = new int[5];

	// number of valid codes pending in buffer

	int bufPos = 0;

	public void write(int b) throws IOException {

	    b &= 0xFF;			// force argument to a byte

	    int pos = codeTable.indexOf((char)b);

	    if (pos != -1)

		writeCode(BASE + pos);

	    else {

		writeCode(RAW);

		writeCode(b >> 4);

		writeCode(b & 0xF);

	    }

	}

	public void write(byte b[], int off, int len) throws IOException {

	    /*

	     * This is quite an inefficient implementation, because it has to

	     * call the other write method for every byte in the array.  It

	     * could be optimized for performance by doing all the processing

	     * in this method.

	     */

	    for (int i = 0; i < len; i++)

		write(b[off + i]);

	}

	public void flush() throws IOException {

	    while (bufPos > 0)

		writeCode(NOP);

	}

	private void writeCode(int c) throws IOException {

	    buf[bufPos++] = c;

	    if (bufPos == 5) {	// write next word when we have 5 codes

		int pack = (buf[0] << 24) | (buf[1] << 18) | (buf[2] << 12) |

		    (buf[3] << 6) | buf[4];

		out.write((pack >>> 24) & 0xFF);

		out.write((pack >>> 16) & 0xFF);

		out.write((pack >>> 8)  & 0xFF);

		out.write((pack >>> 0)  & 0xFF);

		bufPos = 0;

	    }

	}

    }

}