test/jdk/java/rmi/server/RMISocketFactory/useSocketFactory/registry/Compress.java

/*
 * Copyright (c) 1998, 2008, Oracle and/or its affiliates. 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.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;
            }
        }
    }
}