org/openisis/PlainSerializer.java

/*
        openisis - an open implementation of the CDS/ISIS database
        Version 0.8.x (patchlevel see file Version)
        Copyright (C) 2001-2003 by Erik Grziwotz, erik@openisis.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 (at your option) 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

        see README for more information
EOH */

package org.openisis;

import java.io.*;
import java.net.Socket;
import java.util.ArrayList;

/**
        Serialization of fields by plain protocol.
<p>
        $Id: PlainSerializer.java,v 1.8 2003/05/02 18:41:55 mawag Exp $
        @version $Revision: 1.8 $
        @author  $Author: mawag $
*/
public class PlainSerializer {

        private static class ProtocolViolation extends RuntimeException {
                ProtocolViolation () {
                        super ();
                }
                ProtocolViolation (String msg) {
                        super (msg);
                }
                ProtocolViolation (byte arr[]) {
                        super ("got <" + new String (arr) + ">");
                }
        }

        private static class ByteBuf {
                byte _b[];
                int  _cap, _pos;
                ByteBuf (int cap) {
                        _b = new byte [_cap = cap];
                        _pos = 0;
                }
                void append (byte b[], int off, int len) {
                        if (0 < len) {
                                int np = _pos + len;
                                if (np > _cap) {
                                        int nc = _cap;
                                        while (np > (nc *= 2)) {
                                                ;
                                        }
                                        byte nb[] = new byte [nc];
                                        System.arraycopy (_b, 0, nb, 0, _pos);
                                        _b = nb;
                                        _cap = nc;
                                }
                                System.arraycopy (b, off, _b, _pos, len);
                                _pos = np;
                        }
                }
        }

        private static final byte[] NL = new byte [] { (byte)'\n' };
        private static final byte[] HT = new byte [] { (byte)'\t' };
        private static final byte[] VT = new byte [] { (byte)11 };

        private InputStream _in;
        private OutputStream _out;
        private String  _enc = null;
        private boolean _dbg = false;
        private boolean _bin = false;

        private final void _write (byte[] arr, int off, int len) throws Exception {
                if (_dbg) {
                        Log.verbose (this,
                                "w <" + new String (arr, off, len) + ">", null);
                }
                _out.write (arr, off, len);
        }

        private final void _write (byte[] arr) throws Exception {
                if (_dbg) {
                        Log.verbose (this,
                                "w <" + new String (arr, 0, arr.length) + ">", null);
                }
                _out.write (arr);
        }

        private final int _read (byte[] arr) throws Exception {
                int rd = _in.read (arr);
                if (_dbg) {
                        Log.verbose (this,
                                "r <" + new String (arr, 0, rd) + ">", null);
                }
                return rd;
        }

        /**     write end of record to output stream.
                @return success
        */
        public boolean flush () {
                try {
                        _write (NL);
                        return true;
                }
                catch (Exception ex) {
                        Log.warn (this, "flush", ex);
                }
                return false;
        }

        /**     serialize one field.
                @return success
        */
        public boolean write (Field fld) {
                int    j, lst;
                byte[] bv;

                if (null == fld) {
                        return false;
                }
                try {
                        bv = Integer.toString (fld.tag).getBytes ();
                        _write (bv);
                        _write (HT);
                        if (null != fld.val && 0 < fld.val.length ()) {
                                bv = null != _enc ?
                                        fld.val.getBytes (_enc) : fld.val.getBytes ();
                                lst = j = 0;
                                while (bv.length > j) {
                                        if (NL[0] != bv[j]) {
                                                ++j;
                                                continue;
                                        }
                                        if (_bin) {
                                                ++j;
                                                _write (bv, lst, j - lst);
                                                _write (HT);
                                        }
                                        else {
                                                if (j > lst) {
                                                        _write (bv, lst, j - lst);
                                                }
                                                _write (VT);
                                                ++j;
                                        }
                                        lst = j;
                                }
                                if (bv.length > lst) {
                                        _write (bv, lst, bv.length - lst);
                                }
                        }
                        _write (NL);
                        return true;
                }
                catch (Exception ex) {
                        Log.warn (this, "serializing " + fld, ex);
                }
                return false;
        }

        /**     serialize fields.
                @return success
        */
        public boolean write (Field[] flds) {
                if (null == flds) {
                        return false;
                }
                for (int j = 0; flds.length > j; ++j) {
                        if (! write (flds[j])) {
                                return false;
                        }
                }
                return flush ();
        }

        /** deserialize fields.
                @return array of fields read from input stream, null on error
        */
        public Field[] read () {
                byte[]       rbuf = new byte [1024];
                ByteBuf      sbuf = new ByteBuf (1024);
                ArrayList    lst = new ArrayList ();
                Field        fld;
                int          rd, pos, tag, vs, val;
                boolean      rdt; // reading tag
                boolean      lnl; // last byte was NL
                boolean      neg; // tag negative
                boolean      bin = _bin;

                try {
                        tag = 0;
                        rdt = true;
                        neg = false;
                        lnl = false;
all:
                        while (true) {
                                rd = _read (rbuf);
                                if (0 >= rd) {
                                        throw new ProtocolViolation ("no more bytes available");
                                }
                                vs = pos = 0;
                                while (pos < rd) {
                                        if (rdt) {
                                                if (HT[0] == rbuf[pos]) {
                                                        rdt = false;
                                                        vs = ++pos;
                                                        continue;
                                                }
                                                if (0 == tag && '-' == rbuf[pos]) {
                                                        neg = true;
                                                        ++pos;
                                                        continue;
                                                }
                                                val = rbuf[pos] - '0';
                                                if (0 > val || 9 < val) {
                                                        if (0 == pos &&
                                                                NL[0] == rbuf[0] &&
                                                                0 == lst.size ()) {
                                                                Log.warn (this, null,
                                                                        new ProtocolViolation ("empty response"));
                                                                break;
                                                        }
                                                        throw new ProtocolViolation (rbuf);
                                                }
                                                tag = 10 * tag + val;
                                                ++pos;
                                                continue;
                                        }
                                        if (lnl) {
                                                lnl = false;
                                                if (HT[0] == rbuf[pos]) {
                                                        bin = true;
                                                        sbuf.append (NL, 0, 1);
                                                        vs = ++pos;
                                                        continue;
                                                }
                                                fld = new Field (neg ? - tag : tag,
                                                        null == _enc ?
                                                        new String (sbuf._b, 0, sbuf._pos) :
                                                        new String (sbuf._b, 0, sbuf._pos, _enc)
                                                );
                                                lst.add (fld);
                                                if (NL[0] == rbuf[pos]) {
                                                        if (pos != rd - 1) {
                                                                throw new ProtocolViolation ("trailing bytes");
                                                        }
                                                        break all;
                                                }
                                                sbuf._pos = 0;
                                                rdt = true;
                                                neg = false;
                                                tag = 0;
                                                continue;
                                        }
                                        if (VT[0] == rbuf[pos]) {
                                                if (! bin) {
                                                        rbuf[pos] = NL[0];
                                                }
                                        }
                                        else if (NL[0] == rbuf[pos]) {
                                                if (pos > vs) {
                                                        sbuf.append (rbuf, vs, pos - vs);
                                                }
                                                lnl = true;
                                        }
                                        ++pos;
                                }
                                if (! rdt && rd > vs) {
                                        sbuf.append (rbuf, vs, rd - vs);
                                }
                        }

                        return (Field[]) lst.toArray (new Field [lst.size ()]);
                }
                catch (Exception ex) {
                        Log.warn (this, "read", ex);
                }
                return null;
        }

        public void setBinaryMode (boolean bin) {
                _bin = bin;
        }

        /**     Set character encoding to use in subsequent calls to
                read and write.
                @param enc if null, the platforms default encoding will be used
        */
        public void setEncoding (String enc) {
                if (null != enc) {
                        try {
                                new String (NL, enc);
                        }
                        catch (UnsupportedEncodingException ex) {
                                Log.warn (this, "setEncoding(" + enc + ")", ex);
                                return;
                        }
                }
                _enc = enc;
        }

        /** Constructor with read and write stream.
                @param enc character encoding
                @param bin binary mode
        */
        public PlainSerializer (
                InputStream in, OutputStream out, String enc, boolean bin
        ) {
                _in = in;
                _out = out;
                setEncoding (enc);
                setBinaryMode (bin);
                Log.info (this, "ctor(" + enc + "," + bin + ")", null);
        }

        /**     Constructor using text mode and platforms default encoding.
        */
        public PlainSerializer (InputStream in, OutputStream out) {
                this (in, out, null, false);
        }

        /**     Constructor for a socket connection to port@host.
                @param enc character encoding
                @param bin binary mode
                @exception all exceptions a socket might throw
        */
        public PlainSerializer (
                String hostname, int port, String enc, boolean bin
        ) throws Exception {
                try {
                        Socket sock = new Socket (hostname, port);
                        _in = sock.getInputStream ();
                        _out = sock.getOutputStream ();
                        setEncoding (enc);
                        setBinaryMode (bin);
                        Log.info (this, "ctor(" + hostname + ',' + port + "," +
                                enc + "," + bin + ")", null);
                }
                catch (Exception ex) {
                        Log.warn (this, "ctor(" + hostname + ',' + port + ")", ex);
                        throw ex;
                }
        }

        /**     Constructor using text mode and platforms default encoding.
        */
        public PlainSerializer (String hostname, int port) throws Exception {
                this (hostname, port, null, false);
        }

        /**     Close communication channels.
        */
        public void close () {
                if (null != _in) {
                        try {
                                _in.close ();
                        }
                        catch (Exception ex) {
                        }
                        _in = null;
                }
                if (null != _out) {
                        try {
                                _out.close ();
                        }
                        catch (Exception ex) {
                        }
                        _out = null;
                }
        }

//      //////////////////////////////////////////////////////////////////////

        private class PSWriter extends Thread {
                Field[] _rqs;
                int _numr;
                PSWriter (Field[] rqs, int numr) {
                        _rqs = rqs;
                        _numr = numr;
                }
                public void run () {
                        for (int j = 0; _numr > j; ++j) {
                                if (! write (_rqs)) {
                                        Log.warn (null, "error writing rqs #" + j, null);
                                        System.exit (1);
                                }
                                try {
                                        synchronized (PSWriter.this) {
                                                PSWriter.this.wait ();
                                        }
                                }
                                catch (Exception ex) {
                                        Log.warn (PSWriter.this, "wait", ex);
                                }
                        }
                }
        }

        /**     Tester:<br/><pre>
                java org.openisis.PlainSerializer -p
                java org.openisis.PlainSerializer -b -p
                java org.openisis.PlainSerializer -e UTF-8 -p
                java org.openisis.PlainSerializer -e UTF-8 -b -p
                java org.openisis.PlainSerializer -e UTF-16 -p
                java org.openisis.PlainSerializer -e UTF-16 -b -p
                java org.openisis.PlainSerializer -p 55
                java org.openisis.PlainSerializer -b -p 55
                java org.openisis.PlainSerializer -e UTF-16 -p 55
                java org.openisis.PlainSerializer -e UTF-16 -b -p 55
                </pre>
        */
        public static void main (String argv[]) {
                try {
                        String   novel = "blah";
                        String   host  = "localhost";
                        String   enc   = null;
                        int      port  = 8080;
                        int      numr  = 1;
                        boolean  pipe  = false;
                        boolean  dbg   = false;
                        boolean  bin   = false;
                        int      j     = 0;
                        int      len   = argv.length;

                        for (int jj = 0; argv.length > jj; ++jj) {
                                if (argv[jj].startsWith ("-d")) {
                                        dbg = true;
                                        ++j;
                                        --len;
                                        continue;
                                }
                                if (argv[jj].startsWith ("-b")) {
                                        bin = true;
                                        ++j;
                                        --len;
                                        continue;
                                }
                                if (argv[jj].startsWith ("-e")) {
                                        enc = argv[++jj];
                                        j += 2;
                                        len -= 2;
                                        continue;
                                }
                                break;
                        }
                        switch (len) {
                        case 3:
                                numr = Integer.parseInt (argv[2 + j]);
                        case 2:
                                if (argv[j].startsWith ("-p")) {
                                        pipe = true;
                                        numr = Integer.parseInt (argv[1 + j]);
                                        break;
                                }
                                port = Integer.parseInt (argv[1 + j]);
                        case 1:
                                if (argv[j].startsWith ("-p")) {
                                        pipe = true;
                                }
                                else {
                                        host = argv[j];
                                }
                        case 0:
                                break;
                        default:
                                throw new IllegalArgumentException ();
                        }

                        PlainSerializer ps;
                        if (pipe) {
                                PipedInputStream pi = new PipedInputStream ();
                                PipedOutputStream po = new PipedOutputStream (pi);
                                ps = new PlainSerializer (pi, po, enc, bin);
                        }
                        else {
                                ps = new PlainSerializer (host, port, enc, bin);
                        }
                        ps._dbg = dbg;
                        for (j = 0; 8 > j; ++j) {
                                novel = novel + novel;
                        }
                        String[] vals = new String [] {
                                "localhorst",
                                "nothing",
                                "one",
                                null,
                                "",
                                novel,
                                "\nfive\nfire\t",
                                "\t\n\t\n" + (bin ? new String (VT) : ""),
                                "seven",
                                "\n"
                        };
                        Field[] rqs = new Field [] {
                                new Field (-2, vals[0]),
                                new Field (0, vals[1]),
                                new Field (1, vals[2]),
                                new Field (2, vals[3]),
                                new Field (3, vals[4]),
                                new Field (4, vals[5]),
                                new Field (5, vals[6]),
                                new Field (6, vals[7]),
                                new Field (7, vals[8]),
                                new Field (8, vals[9])
                        };
                        int k, kk;
                        Field[] rsp;
                        PSWriter writer = ps.new PSWriter (rqs, numr);
                        writer.start ();

                        for (j = 0; numr > j; ++j) {
                                rsp = ps.read ();
                                if (null == rsp) {
                                        Log.warn (null, "error reading rsp #" + j, null);
                                        System.exit (1);
                                }
                                for (k = kk = 0; rsp.length > k; ++k) {
                                        if (0 > rsp[k].tag) {
                                                if (kk >= rqs.length || ! rsp[k].equals (rqs[kk])) {
                                                        //      skip additional server fields
                                                        if (dbg) {
                                                                Log.verbose (null, "skipping server field " +
                                                                        rsp[k] + " ...", null);
                                                        }
                                                        continue;
                                                }
                                        }
                                        if (rqs.length <= kk) {
                                                for (kk = 0; rsp.length > kk; ++kk) {
                                                        Log.verbose (new Integer (kk),
                                                                rsp[kk].toString (), null);
                                                }
                                                Log.warn (null,
                                                        "length mismatch rsp #" + j + ": " + k + "/" +
                                                        kk + "/" + rsp.length + ">=" + rqs.length,
                                                        null);
                                                System.exit (1);
                                        }
                                        if (! rsp[k].equals (rqs[kk])) {
                                                Log.warn (null, "field #" + k + " rqs #" + j +
                                                        " differs: <" + rsp[k] + "> != <" + rqs[kk] +
                                                        ">", null);
                                                System.exit (1);
                                        }
                                        ++kk;
                                }
                                if (0 != j && 0 == (j % 100)) {
                                        System.out.println (j + " ...");
                                }
                                synchronized (writer) {
                                        writer.notify ();
                                }
                        }
                        ps.close ();

                        System.out.println ("ok.");
                }
                catch (Exception ex) {
                        ex.printStackTrace (System.err);
                        System.err.println ("usage: " + PlainSerializer.class.getName () +
                                " [-b(inary)] [-d(ebug)] [-e(ncoding) <name>]" +
                                " [<hostname=\"localhost\"> [<port> [<numrequests>]]] |" +
                                " -p(ipe) [<numrequests>]");
                        System.exit (1);
                }
        }
}

1	dpavlin	237	/*
2			openisis - an open implementation of the CDS/ISIS database
3			Version 0.8.x (patchlevel see file Version)
4			Copyright (C) 2001-2003 by Erik Grziwotz, erik@openisis.org
5
6			This library is free software; you can redistribute it and/or
7			modify it under the terms of the GNU Lesser General Public
8			License as published by the Free Software Foundation; either
9			version 2.1 of the License, or (at your option) any later version.
10
11			This library is distributed in the hope that it will be useful,
12			but WITHOUT ANY WARRANTY; without even the implied warranty of
13			MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14			Lesser General Public License for more details.
15
16			You should have received a copy of the GNU Lesser General Public
17			License along with this library; if not, write to the Free Software
18			Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19
20			see README for more information
21			EOH */
22
23			package org.openisis;
24
25			import java.io.*;
26			import java.net.Socket;
27			import java.util.ArrayList;
28
29			/**
30			Serialization of fields by plain protocol.
31			<p>
32			$Id: PlainSerializer.java,v 1.8 2003/05/02 18:41:55 mawag Exp $
33			@version $Revision: 1.8 $
34			@author $Author: mawag $
35			*/
36			public class PlainSerializer {
37
38			private static class ProtocolViolation extends RuntimeException {
39			ProtocolViolation () {
40			super ();
41			}
42			ProtocolViolation (String msg) {
43			super (msg);
44			}
45			ProtocolViolation (byte arr[]) {
46			super ("got <" + new String (arr) + ">");
47			}
48			}
49
50			private static class ByteBuf {
51			byte _b[];
52			int _cap, _pos;
53			ByteBuf (int cap) {
54			_b = new byte [_cap = cap];
55			_pos = 0;
56			}
57			void append (byte b[], int off, int len) {
58			if (0 < len) {
59			int np = _pos + len;
60			if (np > _cap) {
61			int nc = _cap;
62			while (np > (nc *= 2)) {
63			;
64			}
65			byte nb[] = new byte [nc];
66			System.arraycopy (_b, 0, nb, 0, _pos);
67			_b = nb;
68			_cap = nc;
69			}
70			System.arraycopy (b, off, _b, _pos, len);
71			_pos = np;
72			}
73			}
74			}
75
76			private static final byte[] NL = new byte [] { (byte)'\n' };
77			private static final byte[] HT = new byte [] { (byte)'\t' };
78			private static final byte[] VT = new byte [] { (byte)11 };
79
80			private InputStream _in;
81			private OutputStream _out;
82			private String _enc = null;
83			private boolean _dbg = false;
84			private boolean _bin = false;
85
86			private final void _write (byte[] arr, int off, int len) throws Exception {
87			if (_dbg) {
88			Log.verbose (this,
89			"w <" + new String (arr, off, len) + ">", null);
90			}
91			_out.write (arr, off, len);
92			}
93
94			private final void _write (byte[] arr) throws Exception {
95			if (_dbg) {
96			Log.verbose (this,
97			"w <" + new String (arr, 0, arr.length) + ">", null);
98			}
99			_out.write (arr);
100			}
101
102			private final int _read (byte[] arr) throws Exception {
103			int rd = _in.read (arr);
104			if (_dbg) {
105			Log.verbose (this,
106			"r <" + new String (arr, 0, rd) + ">", null);
107			}
108			return rd;
109			}
110
111			/** write end of record to output stream.
112			@return success
113			*/
114			public boolean flush () {
115			try {
116			_write (NL);
117			return true;
118			}
119			catch (Exception ex) {
120			Log.warn (this, "flush", ex);
121			}
122			return false;
123			}
124
125			/** serialize one field.
126			@return success
127			*/
128			public boolean write (Field fld) {
129			int j, lst;
130			byte[] bv;
131
132			if (null == fld) {
133			return false;
134			}
135			try {
136			bv = Integer.toString (fld.tag).getBytes ();
137			_write (bv);
138			_write (HT);
139			if (null != fld.val && 0 < fld.val.length ()) {
140			bv = null != _enc ?
141			fld.val.getBytes (_enc) : fld.val.getBytes ();
142			lst = j = 0;
143			while (bv.length > j) {
144			if (NL[0] != bv[j]) {
145			++j;
146			continue;
147			}
148			if (_bin) {
149			++j;
150			_write (bv, lst, j - lst);
151			_write (HT);
152			}
153			else {
154			if (j > lst) {
155			_write (bv, lst, j - lst);
156			}
157			_write (VT);
158			++j;
159			}
160			lst = j;
161			}
162			if (bv.length > lst) {
163			_write (bv, lst, bv.length - lst);
164			}
165			}
166			_write (NL);
167			return true;
168			}
169			catch (Exception ex) {
170			Log.warn (this, "serializing " + fld, ex);
171			}
172			return false;
173			}
174
175			/** serialize fields.
176			@return success
177			*/
178			public boolean write (Field[] flds) {
179			if (null == flds) {
180			return false;
181			}
182			for (int j = 0; flds.length > j; ++j) {
183			if (! write (flds[j])) {
184			return false;
185			}
186			}
187			return flush ();
188			}
189
190			/** deserialize fields.
191			@return array of fields read from input stream, null on error
192			*/
193			public Field[] read () {
194			byte[] rbuf = new byte [1024];
195			ByteBuf sbuf = new ByteBuf (1024);
196			ArrayList lst = new ArrayList ();
197			Field fld;
198			int rd, pos, tag, vs, val;
199			boolean rdt; // reading tag
200			boolean lnl; // last byte was NL
201			boolean neg; // tag negative
202			boolean bin = _bin;
203
204			try {
205			tag = 0;
206			rdt = true;
207			neg = false;
208			lnl = false;
209			all:
210			while (true) {
211			rd = _read (rbuf);
212			if (0 >= rd) {
213			throw new ProtocolViolation ("no more bytes available");
214			}
215			vs = pos = 0;
216			while (pos < rd) {
217			if (rdt) {
218			if (HT[0] == rbuf[pos]) {
219			rdt = false;
220			vs = ++pos;
221			continue;
222			}
223			if (0 == tag && '-' == rbuf[pos]) {
224			neg = true;
225			++pos;
226			continue;
227			}
228			val = rbuf[pos] - '0';
229			if (0 > val \|\| 9 < val) {
230			if (0 == pos &&
231			NL[0] == rbuf[0] &&
232			0 == lst.size ()) {
233			Log.warn (this, null,
234			new ProtocolViolation ("empty response"));
235			break;
236			}
237			throw new ProtocolViolation (rbuf);
238			}
239			tag = 10 * tag + val;
240			++pos;
241			continue;
242			}
243			if (lnl) {
244			lnl = false;
245			if (HT[0] == rbuf[pos]) {
246			bin = true;
247			sbuf.append (NL, 0, 1);
248			vs = ++pos;
249			continue;
250			}
251			fld = new Field (neg ? - tag : tag,
252			null == _enc ?
253			new String (sbuf._b, 0, sbuf._pos) :
254			new String (sbuf._b, 0, sbuf._pos, _enc)
255			);
256			lst.add (fld);
257			if (NL[0] == rbuf[pos]) {
258			if (pos != rd - 1) {
259			throw new ProtocolViolation ("trailing bytes");
260			}
261			break all;
262			}
263			sbuf._pos = 0;
264			rdt = true;
265			neg = false;
266			tag = 0;
267			continue;
268			}
269			if (VT[0] == rbuf[pos]) {
270			if (! bin) {
271			rbuf[pos] = NL[0];
272			}
273			}
274			else if (NL[0] == rbuf[pos]) {
275			if (pos > vs) {
276			sbuf.append (rbuf, vs, pos - vs);
277			}
278			lnl = true;
279			}
280			++pos;
281			}
282			if (! rdt && rd > vs) {
283			sbuf.append (rbuf, vs, rd - vs);
284			}
285			}
286
287			return (Field[]) lst.toArray (new Field [lst.size ()]);
288			}
289			catch (Exception ex) {
290			Log.warn (this, "read", ex);
291			}
292			return null;
293			}
294
295			public void setBinaryMode (boolean bin) {
296			_bin = bin;
297			}
298
299			/** Set character encoding to use in subsequent calls to
300			read and write.
301			@param enc if null, the platforms default encoding will be used
302			*/
303			public void setEncoding (String enc) {
304			if (null != enc) {
305			try {
306			new String (NL, enc);
307			}
308			catch (UnsupportedEncodingException ex) {
309			Log.warn (this, "setEncoding(" + enc + ")", ex);
310			return;
311			}
312			}
313			_enc = enc;
314			}
315
316			/** Constructor with read and write stream.
317			@param enc character encoding
318			@param bin binary mode
319			*/
320			public PlainSerializer (
321			InputStream in, OutputStream out, String enc, boolean bin
322			) {
323			_in = in;
324			_out = out;
325			setEncoding (enc);
326			setBinaryMode (bin);
327			Log.info (this, "ctor(" + enc + "," + bin + ")", null);
328			}
329
330			/** Constructor using text mode and platforms default encoding.
331			*/
332			public PlainSerializer (InputStream in, OutputStream out) {
333			this (in, out, null, false);
334			}
335
336			/** Constructor for a socket connection to port@host.
337			@param enc character encoding
338			@param bin binary mode
339			@exception all exceptions a socket might throw
340			*/
341			public PlainSerializer (
342			String hostname, int port, String enc, boolean bin
343			) throws Exception {
344			try {
345			Socket sock = new Socket (hostname, port);
346			_in = sock.getInputStream ();
347			_out = sock.getOutputStream ();
348			setEncoding (enc);
349			setBinaryMode (bin);
350			Log.info (this, "ctor(" + hostname + ',' + port + "," +
351			enc + "," + bin + ")", null);
352			}
353			catch (Exception ex) {
354			Log.warn (this, "ctor(" + hostname + ',' + port + ")", ex);
355			throw ex;
356			}
357			}
358
359			/** Constructor using text mode and platforms default encoding.
360			*/
361			public PlainSerializer (String hostname, int port) throws Exception {
362			this (hostname, port, null, false);
363			}
364
365			/** Close communication channels.
366			*/
367			public void close () {
368			if (null != _in) {
369			try {
370			_in.close ();
371			}
372			catch (Exception ex) {
373			}
374			_in = null;
375			}
376			if (null != _out) {
377			try {
378			_out.close ();
379			}
380			catch (Exception ex) {
381			}
382			_out = null;
383			}
384			}
385
386			// //////////////////////////////////////////////////////////////////////
387
388			private class PSWriter extends Thread {
389			Field[] _rqs;
390			int _numr;
391			PSWriter (Field[] rqs, int numr) {
392			_rqs = rqs;
393			_numr = numr;
394			}
395			public void run () {
396			for (int j = 0; _numr > j; ++j) {
397			if (! write (_rqs)) {
398			Log.warn (null, "error writing rqs #" + j, null);
399			System.exit (1);
400			}
401			try {
402			synchronized (PSWriter.this) {
403			PSWriter.this.wait ();
404			}
405			}
406			catch (Exception ex) {
407			Log.warn (PSWriter.this, "wait", ex);
408			}
409			}
410			}
411			}
412
413			/** Tester:<br/><pre>
414			java org.openisis.PlainSerializer -p
415			java org.openisis.PlainSerializer -b -p
416			java org.openisis.PlainSerializer -e UTF-8 -p
417			java org.openisis.PlainSerializer -e UTF-8 -b -p
418			java org.openisis.PlainSerializer -e UTF-16 -p
419			java org.openisis.PlainSerializer -e UTF-16 -b -p
420			java org.openisis.PlainSerializer -p 55
421			java org.openisis.PlainSerializer -b -p 55
422			java org.openisis.PlainSerializer -e UTF-16 -p 55
423			java org.openisis.PlainSerializer -e UTF-16 -b -p 55
424			</pre>
425			*/
426			public static void main (String argv[]) {
427			try {
428			String novel = "blah";
429			String host = "localhost";
430			String enc = null;
431			int port = 8080;
432			int numr = 1;
433			boolean pipe = false;
434			boolean dbg = false;
435			boolean bin = false;
436			int j = 0;
437			int len = argv.length;
438
439			for (int jj = 0; argv.length > jj; ++jj) {
440			if (argv[jj].startsWith ("-d")) {
441			dbg = true;
442			++j;
443			--len;
444			continue;
445			}
446			if (argv[jj].startsWith ("-b")) {
447			bin = true;
448			++j;
449			--len;
450			continue;
451			}
452			if (argv[jj].startsWith ("-e")) {
453			enc = argv[++jj];
454			j += 2;
455			len -= 2;
456			continue;
457			}
458			break;
459			}
460			switch (len) {
461			case 3:
462			numr = Integer.parseInt (argv[2 + j]);
463			case 2:
464			if (argv[j].startsWith ("-p")) {
465			pipe = true;
466			numr = Integer.parseInt (argv[1 + j]);
467			break;
468			}
469			port = Integer.parseInt (argv[1 + j]);
470			case 1:
471			if (argv[j].startsWith ("-p")) {
472			pipe = true;
473			}
474			else {
475			host = argv[j];
476			}
477			case 0:
478			break;
479			default:
480			throw new IllegalArgumentException ();
481			}
482
483			PlainSerializer ps;
484			if (pipe) {
485			PipedInputStream pi = new PipedInputStream ();
486			PipedOutputStream po = new PipedOutputStream (pi);
487			ps = new PlainSerializer (pi, po, enc, bin);
488			}
489			else {
490			ps = new PlainSerializer (host, port, enc, bin);
491			}
492			ps._dbg = dbg;
493			for (j = 0; 8 > j; ++j) {
494			novel = novel + novel;
495			}
496			String[] vals = new String [] {
497			"localhorst",
498			"nothing",
499			"one",
500			null,
501			"",
502			novel,
503			"\nfive\nfire\t",
504			"\t\n\t\n" + (bin ? new String (VT) : ""),
505			"seven",
506			"\n"
507			};
508			Field[] rqs = new Field [] {
509			new Field (-2, vals[0]),
510			new Field (0, vals[1]),
511			new Field (1, vals[2]),
512			new Field (2, vals[3]),
513			new Field (3, vals[4]),
514			new Field (4, vals[5]),
515			new Field (5, vals[6]),
516			new Field (6, vals[7]),
517			new Field (7, vals[8]),
518			new Field (8, vals[9])
519			};
520			int k, kk;
521			Field[] rsp;
522			PSWriter writer = ps.new PSWriter (rqs, numr);
523			writer.start ();
524
525			for (j = 0; numr > j; ++j) {
526			rsp = ps.read ();
527			if (null == rsp) {
528			Log.warn (null, "error reading rsp #" + j, null);
529			System.exit (1);
530			}
531			for (k = kk = 0; rsp.length > k; ++k) {
532			if (0 > rsp[k].tag) {
533			if (kk >= rqs.length \|\| ! rsp[k].equals (rqs[kk])) {
534			// skip additional server fields
535			if (dbg) {
536			Log.verbose (null, "skipping server field " +
537			rsp[k] + " ...", null);
538			}
539			continue;
540			}
541			}
542			if (rqs.length <= kk) {
543			for (kk = 0; rsp.length > kk; ++kk) {
544			Log.verbose (new Integer (kk),
545			rsp[kk].toString (), null);
546			}
547			Log.warn (null,
548			"length mismatch rsp #" + j + ": " + k + "/" +
549			kk + "/" + rsp.length + ">=" + rqs.length,
550			null);
551			System.exit (1);
552			}
553			if (! rsp[k].equals (rqs[kk])) {
554			Log.warn (null, "field #" + k + " rqs #" + j +
555			" differs: <" + rsp[k] + "> != <" + rqs[kk] +
556			">", null);
557			System.exit (1);
558			}
559			++kk;
560			}
561			if (0 != j && 0 == (j % 100)) {
562			System.out.println (j + " ...");
563			}
564			synchronized (writer) {
565			writer.notify ();
566			}
567			}
568			ps.close ();
569
570			System.out.println ("ok.");
571			}
572			catch (Exception ex) {
573			ex.printStackTrace (System.err);
574			System.err.println ("usage: " + PlainSerializer.class.getName () +
575			" [-b(inary)] [-d(ebug)] [-e(ncoding) <name>]" +
576			" [<hostname=\"localhost\"> [<port> [<numrequests>]]] \|" +
577			" -p(ipe) [<numrequests>]");
578			System.exit (1);
579			}
580			}
581			}
582