files)
+ {
+ while (!files.isEmpty())
+ addFile(files.removeLast());
+ }
+
+ private void findFiles() throws IOException
+ {
+ Calendar date = Calendar.getInstance();
+ while (_previousFiles.size() < _count)
+ {
+ date.add(Calendar.DAY_OF_MONTH, -1);
+ String pattern = _pattern.replace("%d", format.format(date.getTime()));
+ for (int unique=0; unique<_count; unique++)
+ {
+ for (int generation=0; generation<_count; generation++)
+ {
+ File f = MyFileHandler.generate(pattern, generation, unique, _count);
+ if (f.exists() && !_previousFiles.contains(f))
+ {
+ _previousFiles.addLast(f);
+ }
+ else
+ {
+ break;
+ }
+ }
+ File f = MyFileHandler.generate(pattern, 0, unique, _count);
+ if (!f.exists() || _previousFiles.contains(f))
+ break;
+ }
+ File f = MyFileHandler.generate(pattern, 0, 0, _count);
+ if (!f.exists())
+ break;
+ }
+
+ }
+ */
+
+}
diff --git a/javaUtilities/yajsw/src/app/java/org/rzo/yajsw/log/MyFileHandler.java b/javaUtilities/yajsw/src/app/java/org/rzo/yajsw/log/MyFileHandler.java
new file mode 100644
index 0000000000..65bd774101
--- /dev/null
+++ b/javaUtilities/yajsw/src/app/java/org/rzo/yajsw/log/MyFileHandler.java
@@ -0,0 +1,661 @@
+package org.rzo.yajsw.log;
+
+/*
+ * @(#)FileHandler.java 1.37 10/03/23
+ *
+ * Copyright (c) 2006, Oracle and/or its affiliates. All rights reserved.
+ * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
+ */
+
+import java.io.*;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.security.*;
+import java.util.LinkedList;
+import java.util.logging.ErrorManager;
+import java.util.logging.Level;
+import java.util.logging.LogManager;
+import java.util.logging.LogRecord;
+import java.util.logging.StreamHandler;
+
+/**
+ * Simple file logging Handler .
+ *
+ * The FileHandler can either write to a specified file,
+ * or it can write to a rotating set of files.
+ *
+ * For a rotating set of files, as each file reaches a given size
+ * limit, it is closed, rotated out, and a new file opened.
+ * Successively older files are named by adding "0", "1", "2",
+ * etc into the base filename.
+ *
+ * By default buffering is enabled in the IO libraries but each log
+ * record is flushed out when it is complete.
+ *
+ * By default the XMLFormatter class is used for formatting.
+ *
+ * Configuration:
+ * By default each FileHandler is initialized using the following
+ * LogManager configuration properties. If properties are not defined
+ * (or have invalid values) then the specified default values are used.
+ *
+ * java.util.logging.FileHandler.level
+ * specifies the default level for the Handler
+ * (defaults to Level.ALL ).
+ * java.util.logging.FileHandler.filter
+ * specifies the name of a Filter class to use
+ * (defaults to no Filter ).
+ * java.util.logging.FileHandler.formatter
+ * specifies the name of a Formatter class to use
+ * (defaults to java.util.logging.XMLFormatter )
+ * java.util.logging.FileHandler.encoding
+ * the name of the character set encoding to use (defaults to
+ * the default platform encoding).
+ * java.util.logging.FileHandler.limit
+ * specifies an approximate maximum amount to write (in bytes)
+ * to any one file. If this is zero, then there is no limit.
+ * (Defaults to no limit).
+ * java.util.logging.FileHandler.count
+ * specifies how many output files to cycle through (defaults to 1).
+ * java.util.logging.FileHandler.pattern
+ * specifies a pattern for generating the output file name. See
+ * below for details. (Defaults to "%h/java%u.log").
+ * java.util.logging.FileHandler.append
+ * specifies whether the FileHandler should append onto
+ * any existing files (defaults to false).
+ *
+ *
+ *
+ * A pattern consists of a string that includes the following special
+ * components that will be replaced at runtime:
+ *
+ * "/" the local pathname separator
+ * "%t" the system temporary directory
+ * "%h" the value of the "user.home" system property
+ * "%g" the generation number to distinguish rotated logs
+ * "%u" a unique number to resolve conflicts
+ * "%%" translates to a single percent sign "%"
+ *
+ * If no "%g" field has been specified and the file count is greater
+ * than one, then the generation number will be added to the end of
+ * the generated filename, after a dot.
+ *
+ * Thus for example a pattern of "%t/java%g.log" with a count of 2
+ * would typically cause log files to be written on Solaris to
+ * /var/tmp/java0.log and /var/tmp/java1.log whereas on Windows 95 they
+ * would be typically written to C:\TEMP\java0.log and C:\TEMP\java1.log
+ *
+ * Generation numbers follow the sequence 0, 1, 2, etc.
+ *
+ * Normally the "%u" unique field is set to 0. However, if the FileHandler
+ * tries to open the filename and finds the file is currently in use by
+ * another process it will increment the unique number field and try
+ * again. This will be repeated until FileHandler finds a file name that
+ * is not currently in use. If there is a conflict and no "%u" field has
+ * been specified, it will be added at the end of the filename after a dot.
+ * (This will be after any automatically added generation number.)
+ *
+ * Thus if three processes were all trying to log to fred%u.%g.txt then
+ * they might end up using fred0.0.txt, fred1.0.txt, fred2.0.txt as
+ * the first file in their rotating sequences.
+ *
+ * Note that the use of unique ids to avoid conflicts is only guaranteed
+ * to work reliably when using a local disk file system.
+ *
+ * @version 1.37, 03/23/10
+ * @since 1.4
+ */
+
+public class MyFileHandler extends StreamHandler {
+ private MeteredStream meter;
+ private boolean append;
+ private int limit; // zero => no limit.
+ private int count;
+ private String pattern;
+ private String lockFileName;
+ private FileOutputStream lockStream;
+ private File files[];
+ private static final int MAX_LOCKS = 100;
+ private static java.util.HashMap locks = new java.util.HashMap();
+
+ private FileChangeListner _listener = null;
+
+ interface FileChangeListner
+ {
+ void fileChange(File file, boolean added);
+ }
+
+ // A metered stream is a subclass of OutputStream that
+ // (a) forwards all its output to a target stream
+ // (b) keeps track of how many bytes have been written
+ private class MeteredStream extends OutputStream {
+ OutputStream out;
+ int written;
+
+ MeteredStream(OutputStream out, int written) {
+ this.out = out;
+ this.written = written;
+ }
+
+ public void write(int b) throws IOException {
+ out.write(b);
+ written++;
+ }
+
+ public void write(byte buff[]) throws IOException {
+ out.write(buff);
+ written += buff.length;
+ }
+
+ public void write(byte buff[], int off, int len) throws IOException {
+ out.write(buff,off,len);
+ written += len;
+ }
+
+ public void flush() throws IOException {
+ out.flush();
+ }
+
+ public void close() throws IOException {
+ out.close();
+ }
+ }
+
+ private void open(File fname, boolean append) throws IOException {
+ int len = 0;
+ if (append) {
+ len = (int)fname.length();
+ }
+ if (!fname.getParentFile().exists())
+ fname.getParentFile().mkdirs();
+ FileOutputStream fout = new FileOutputStream(fname.toString(), append);
+ BufferedOutputStream bout = new BufferedOutputStream(fout);
+ meter = new MeteredStream(bout, len);
+ setOutputStream(meter);
+ }
+
+ // Private method to configure a FileHandler from LogManager
+ // properties and/or default values as specified in the class
+ // javadoc.
+ private void configure() {
+ /*
+ LogManager manager = LogManager.getLogManager();
+
+ String cname = getClass().getName();
+
+ pattern = manager.getStringProperty(cname + ".pattern", "%h/java%u.log");
+ limit = manager.getIntProperty(cname + ".limit", 0);
+ if (limit < 0) {
+ limit = 0;
+ }
+ count = manager.getIntProperty(cname + ".count", 1);
+ if (count <= 0) {
+ count = 1;
+ }
+ append = manager.getBooleanProperty(cname + ".append", false);
+ setLevel(manager.getLevelProperty(cname + ".level", Level.ALL));
+ setFilter(manager.getFilterProperty(cname + ".filter", null));
+ setFormatter(manager.getFormatterProperty(cname + ".formatter", new XMLFormatter()));
+ try {
+ setEncoding(manager.getStringProperty(cname +".encoding", null));
+ } catch (Exception ex) {
+ try {
+ setEncoding(null);
+ } catch (Exception ex2) {
+ // doing a setEncoding with null should always work.
+ // assert false;
+ }
+ }
+ */
+ }
+
+
+ /**
+ * Construct a default FileHandler . This will be configured
+ * entirely from LogManager properties (or their default values).
+ *
+ * @exception IOException if there are IO problems opening the files.
+ * @exception SecurityException if a security manager exists and if
+ * the caller does not have LoggingPermission("control")) .
+ * @exception NullPointerException if pattern property is an empty String.
+ */
+ public MyFileHandler() throws IOException, SecurityException {
+ //checkAccess();
+ configure();
+ openFiles();
+ }
+
+ /**
+ * Initialize a FileHandler to write to the given filename.
+ *
+ * The FileHandler is configured based on LogManager
+ * properties (or their default values) except that the given pattern
+ * argument is used as the filename pattern, the file limit is
+ * set to no limit, and the file count is set to one.
+ *
+ * There is no limit on the amount of data that may be written,
+ * so use this with care.
+ *
+ * @param pattern the name of the output file
+ * @exception IOException if there are IO problems opening the files.
+ * @exception SecurityException if a security manager exists and if
+ * the caller does not have LoggingPermission("control") .
+ * @exception IllegalArgumentException if pattern is an empty string
+ */
+ public MyFileHandler(String pattern) throws IOException, SecurityException {
+ if (pattern.length() < 1 ) {
+ throw new IllegalArgumentException();
+ }
+ //checkAccess();
+ configure();
+ this.pattern = pattern;
+ this.limit = 0;
+ this.count = 1;
+ openFiles();
+ }
+
+ /**
+ * Initialize a FileHandler to write to the given filename,
+ * with optional append.
+ *
+ * The FileHandler is configured based on LogManager
+ * properties (or their default values) except that the given pattern
+ * argument is used as the filename pattern, the file limit is
+ * set to no limit, the file count is set to one, and the append
+ * mode is set to the given append argument.
+ *
+ * There is no limit on the amount of data that may be written,
+ * so use this with care.
+ *
+ * @param pattern the name of the output file
+ * @param append specifies append mode
+ * @exception IOException if there are IO problems opening the files.
+ * @exception SecurityException if a security manager exists and if
+ * the caller does not have LoggingPermission("control") .
+ * @exception IllegalArgumentException if pattern is an empty string
+ */
+ public MyFileHandler(String pattern, boolean append) throws IOException, SecurityException {
+ if (pattern.length() < 1 ) {
+ throw new IllegalArgumentException();
+ }
+ //checkAccess();
+ configure();
+ this.pattern = pattern;
+ this.limit = 0;
+ this.count = 1;
+ this.append = append;
+ openFiles();
+ }
+
+ /**
+ * Initialize a FileHandler to write to a set of files. When
+ * (approximately) the given limit has been written to one file,
+ * another file will be opened. The output will cycle through a set
+ * of count files.
+ *
+ * The FileHandler is configured based on LogManager
+ * properties (or their default values) except that the given pattern
+ * argument is used as the filename pattern, the file limit is
+ * set to the limit argument, and the file count is set to the
+ * given count argument.
+ *
+ * The count must be at least 1.
+ *
+ * @param pattern the pattern for naming the output file
+ * @param limit the maximum number of bytes to write to any one file
+ * @param count the number of files to use
+ * @exception IOException if there are IO problems opening the files.
+ * @exception SecurityException if a security manager exists and if
+ * the caller does not have LoggingPermission("control") .
+ * @exception IllegalArgumentException if limit < 0, or count < 1.
+ * @exception IllegalArgumentException if pattern is an empty string
+ */
+ public MyFileHandler(String pattern, int limit, int count)
+ throws IOException, SecurityException {
+ if (limit < 0 || count < 1 || pattern.length() < 1) {
+ throw new IllegalArgumentException();
+ }
+ //checkAccess();
+ configure();
+ this.pattern = pattern;
+ this.limit = limit;
+ this.count = count;
+ openFiles();
+ }
+
+ /**
+ * Initialize a FileHandler to write to a set of files
+ * with optional append. When (approximately) the given limit has
+ * been written to one file, another file will be opened. The
+ * output will cycle through a set of count files.
+ *
+ * The FileHandler is configured based on LogManager
+ * properties (or their default values) except that the given pattern
+ * argument is used as the filename pattern, the file limit is
+ * set to the limit argument, and the file count is set to the
+ * given count argument, and the append mode is set to the given
+ * append argument.
+ *
+ * The count must be at least 1.
+ *
+ * @param pattern the pattern for naming the output file
+ * @param limit the maximum number of bytes to write to any one file
+ * @param count the number of files to use
+ * @param append specifies append mode
+ * @exception IOException if there are IO problems opening the files.
+ * @exception SecurityException if a security manager exists and if
+ * the caller does not have LoggingPermission("control") .
+ * @exception IllegalArgumentException if limit < 0, or count < 1.
+ * @exception IllegalArgumentException if pattern is an empty string
+ *
+ */
+ public MyFileHandler(String pattern, int limit, int count, boolean append)
+ throws IOException, SecurityException {
+ if (limit < 0 || count < 1 || pattern.length() < 1) {
+ throw new IllegalArgumentException();
+ }
+ //checkAccess();
+ configure();
+ this.pattern = pattern;
+ this.limit = limit;
+ this.count = count;
+ this.append = append;
+ openFiles();
+ }
+
+ public MyFileHandler(String pattern, int limit, int count, boolean append, PatternFormatter fileFormatter, Level logLevel, String encoding) throws SecurityException, IOException
+ {
+ this(pattern, limit, count, append);
+ if (encoding != null)
+ setEncoding(encoding);
+ setFormatter(fileFormatter);
+ setLevel(logLevel);
+ }
+
+ // Private method to open the set of output files, based on the
+ // configured instance variables.
+ private void openFiles() throws IOException {
+ LogManager manager = LogManager.getLogManager();
+ manager.checkAccess();
+ if (count < 1) {
+ throw new IllegalArgumentException("file count = " + count);
+ }
+ if (limit < 0) {
+ limit = 0;
+ }
+
+ // We register our own ErrorManager during initialization
+ // so we can record exceptions.
+ InitializationErrorManager em = new InitializationErrorManager();
+ setErrorManager(em);
+
+ // Create a lock file. This grants us exclusive access
+ // to our set of output files, as long as we are alive.
+ int unique = -1;
+ for (;;) {
+ unique++;
+ if (unique > MAX_LOCKS) {
+ throw new IOException("Couldn't get lock for " + pattern);
+ }
+ // Generate a lock file name from the "unique" int.
+ lockFileName = generate(pattern, 0, unique, count).toString() + ".lck";
+ // Now try to lock that filename.
+ // Because some systems (e.g. Solaris) can only do file locks
+ // between processes (and not within a process), we first check
+ // if we ourself already have the file locked.
+ synchronized(locks) {
+ if (locks.get(lockFileName) != null) {
+ // We already own this lock, for a different FileHandler
+ // object. Try again.
+ continue;
+ }
+ FileChannel fc;
+ try {
+ lockStream = new FileOutputStream(lockFileName);
+ fc = lockStream.getChannel();
+ } catch (IOException ix) {
+ // We got an IOException while trying to open the file.
+ // Try the next file.
+ continue;
+ }
+ try {
+ FileLock fl = fc.tryLock();
+ if (fl == null) {
+ // We failed to get the lock. Try next file.
+ continue;
+ }
+ // We got the lock OK.
+ } catch (IOException ix) {
+ // We got an IOException while trying to get the lock.
+ // This normally indicates that locking is not supported
+ // on the target directory. We have to proceed without
+ // getting a lock. Drop through.
+ }
+ // We got the lock. Remember it.
+ locks.put(lockFileName, lockFileName);
+ break;
+ }
+ }
+
+ files = new File[count];
+ for (int i = 0; i < count; i++) {
+ files[i] = generate(pattern, i, unique, count);
+ }
+
+ // Create the initial log file.
+ if (append) {
+ open(files[0], true);
+ } else {
+ rotate();
+ }
+
+ // Did we detect any exceptions during initialization?
+ Exception ex = em.lastException;
+ if (ex != null) {
+ if (ex instanceof IOException) {
+ throw (IOException) ex;
+ } else if (ex instanceof SecurityException) {
+ throw (SecurityException) ex;
+ } else {
+ throw new IOException("Exception: " + ex);
+ }
+ }
+
+ // Install the normal default ErrorManager.
+ setErrorManager(new ErrorManager());
+ }
+
+ // Generate a filename from a pattern.
+ static File generate(String pattern, int generation, int unique, int count) throws IOException {
+ File file = null;
+ String word = "";
+ int ix = 0;
+ boolean sawg = false;
+ boolean sawu = false;
+ while (ix < pattern.length()) {
+ char ch = pattern.charAt(ix);
+ ix++;
+ char ch2 = 0;
+ if (ix < pattern.length()) {
+ ch2 = Character.toLowerCase(pattern.charAt(ix));
+ }
+ if (ch == '/') {
+ if (file == null) {
+ file = new File(word);
+ } else {
+ file = new File(file, word);
+ }
+ word = "";
+ continue;
+ } else if (ch == '%') {
+ if (ch2 == 't') {
+ String tmpDir = System.getProperty("java.io.tmpdir");
+ if (tmpDir == null) {
+ tmpDir = System.getProperty("user.home");
+ }
+ file = new File(tmpDir);
+ ix++;
+ word = "";
+ continue;
+ } else if (ch2 == 'h') {
+ file = new File(System.getProperty("user.home"));
+ if (isSetUID()) {
+ // Ok, we are in a set UID program. For safety's sake
+ // we disallow attempts to open files relative to %h.
+ throw new IOException("can't use %h in set UID program");
+ }
+ ix++;
+ word = "";
+ continue;
+ } else if (ch2 == 'g') {
+ word = word + generation;
+ sawg = true;
+ ix++;
+ continue;
+ } else if (ch2 == 'u') {
+ word = word + unique;
+ sawu = true;
+ ix++;
+ continue;
+ } else if (ch2 == '%') {
+ word = word + "%";
+ ix++;
+ continue;
+ }
+ }
+ word = word + ch;
+ }
+ if (count > 1 && !sawg && generation != 0) {
+ word = word + "." + generation;
+ }
+ if (unique > 0 && !sawu && unique != 0) {
+ word = word + "." + unique;
+ }
+ if (word.length() > 0) {
+ if (file == null) {
+ file = new File(word);
+ } else {
+ file = new File(file, word);
+ }
+ }
+ return file;
+ }
+
+ // Rotate the set of output files
+ private synchronized void rotate() {
+ Level oldLevel = getLevel();
+ setLevel(Level.OFF);
+
+ super.close();
+ for (int i = count-2; i >= 0; i--) {
+ File f1 = files[i];
+ File f2 = files[i+1];
+ if (f1.exists()) {
+ if (f2.exists()) {
+ f2.delete();
+ }
+ else if (_listener != null)
+ _listener.fileChange(f2, true);
+ f1.renameTo(f2);
+ }
+ }
+ try {
+ open(files[0], false);
+ } catch (IOException ix) {
+ // We don't want to throw an exception here, but we
+ // report the exception to any registered ErrorManager.
+ reportError(null, ix, ErrorManager.OPEN_FAILURE);
+
+ }
+ setLevel(oldLevel);
+ }
+
+ /**
+ * Format and publish a LogRecord .
+ *
+ * @param record description of the log event. A null record is
+ * silently ignored and is not published
+ */
+ public synchronized void publish(LogRecord record) {
+ if (!isLoggable(record)) {
+ return;
+ }
+ super.publish(record);
+ flush();
+ if (limit > 0 && meter.written >= limit) {
+ // We performed access checks in the "init" method to make sure
+ // we are only initialized from trusted code. So we assume
+ // it is OK to write the target files, even if we are
+ // currently being called from untrusted code.
+ // So it is safe to raise privilege here.
+ AccessController.doPrivileged(new PrivilegedAction() {
+ public Object run() {
+ rotate();
+ return null;
+ }
+ });
+ }
+ }
+
+ public File currentFile()
+ {
+ return files[0];
+ }
+
+ public LinkedList getCurrentFiles()
+ {
+ LinkedList result = new LinkedList();
+ for (File f : files)
+ {
+ if (f.exists())
+ result.addLast(f);
+ else
+ break;
+ }
+ return result;
+ }
+
+ public void setNewFileListner(FileChangeListner listener)
+ {
+ _listener = listener;
+ }
+
+ /**
+ * Close all the files.
+ *
+ * @exception SecurityException if a security manager exists and if
+ * the caller does not have LoggingPermission("control") .
+ */
+ public synchronized void close() throws SecurityException {
+ super.close();
+ // Unlock any lock file.
+ if (lockFileName == null) {
+ return;
+ }
+ try {
+ // Closing the lock file's FileOutputStream will close
+ // the underlying channel and free any locks.
+ lockStream.close();
+ } catch (Exception ex) {
+ // Problems closing the stream. Punt.
+ }
+ synchronized(locks) {
+ locks.remove(lockFileName);
+ }
+ new File(lockFileName).delete();
+ lockFileName = null;
+ lockStream = null;
+ }
+
+ private static class InitializationErrorManager extends ErrorManager {
+ Exception lastException;
+ public void error(String msg, Exception ex, int code) {
+ lastException = ex;
+ }
+ }
+
+ // Private native method to check if we are in a set UID program.
+ private static native boolean isSetUID();
+}
+
+
diff --git a/javaUtilities/yajsw/src/app/java/org/rzo/yajsw/log/MyLogger.java b/javaUtilities/yajsw/src/app/java/org/rzo/yajsw/log/MyLogger.java
new file mode 100644
index 0000000000..31706a2d2f
--- /dev/null
+++ b/javaUtilities/yajsw/src/app/java/org/rzo/yajsw/log/MyLogger.java
@@ -0,0 +1,70 @@
+/* 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.
+ */
+package org.rzo.yajsw.log;
+
+import java.util.Arrays;
+import java.util.logging.LogRecord;
+import java.util.logging.Logger;
+
+// TODO: Auto-generated Javadoc
+/**
+ * The Class MyLogger.
+ */
+public class MyLogger extends Logger
+{
+
+ /** The _name. */
+ String _pid;
+ String _name;
+
+ /**
+ * Instantiates a new my logger.
+ */
+ public MyLogger()
+ {
+ super(null, null);
+ }
+
+ /**
+ * Sets the name.
+ *
+ * @param name
+ * the new name
+ */
+ public void setPID(String pid)
+ {
+ _pid = pid;
+ }
+
+ public void setName(String name)
+ {
+ _name = name;
+ }
+
+ @Override
+ public void log(LogRecord record)
+ {
+ Object[] newParams = null;
+ Object[] params = record.getParameters();
+ if (params == null || params.length == 0)
+ newParams = new String[] { _pid, _name };
+ else
+ {
+ int newSize = params.length + 2;
+ newParams = Arrays.copyOf(params, newSize);
+ newParams[newSize - 2] = _pid;
+ newParams[newSize - 1] = _name;
+ }
+
+ record.setParameters(newParams);
+ super.log(record);
+ }
+}
diff --git a/javaUtilities/yajsw/src/app/java/org/rzo/yajsw/log/PatternFormatter.java b/javaUtilities/yajsw/src/app/java/org/rzo/yajsw/log/PatternFormatter.java
new file mode 100644
index 0000000000..9545d70489
--- /dev/null
+++ b/javaUtilities/yajsw/src/app/java/org/rzo/yajsw/log/PatternFormatter.java
@@ -0,0 +1,253 @@
+/**
+ * Copyright [2007] [Rohit B. Rai]
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.rzo.yajsw.log;
+
+import java.text.DateFormat;
+import java.text.MessageFormat;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.logging.Formatter;
+import java.util.logging.LogManager;
+import java.util.logging.LogRecord;
+
+// TODO: Auto-generated Javadoc
+/**
+ * The Class PatternFormatter.
+ */
+public class PatternFormatter extends Formatter
+{
+
+ /** The sh. */
+ java.util.logging.SimpleFormatter sh;
+
+ /**
+ *
+ * The Log Formatter will use the following formatting tokens LoggerName %LOGGER% Level %LEVEL% Time %TIME% Message %MESSAGE% SourceClassName %SOURCECLASS% SourceMethodName %SOURCEMETHOD% Exception Message %EXCEPTION% ExceptionStackTrace %STACKTRACE% Parameter %PARAM%
+ *
+ *
+ * The default log format is "[%LOGGER% - %LEVEL%] %TIME%: %MESSAGE%" And
+ * exception format is [%LOGGER% - %LEVEL%] %TIME% %MESSAGE% \n Exception:
+ * %EXCEPTION% \n %STACKTRACE% Apart from this the time format may be
+ * specified in satand java time format in the timeFormat variable The
+ * default time format is "dd-MMM-yyy; HH:mm:ss".
+ */
+
+ private String logPattern;
+
+ /** The exception pattern. */
+ private String exceptionPattern;
+
+ /** The time format. */
+ private String timeFormat;
+
+ /** The log message format. */
+ private MessageFormat logMessageFormat;
+
+ /** The exception message format. */
+ private MessageFormat exceptionMessageFormat;
+
+ /** The date format. */
+ private DateFormat dateFormat;
+
+ /**
+ * Instantiates a new pattern formatter.
+ */
+ public PatternFormatter()
+ {
+ LogManager manager = LogManager.getLogManager();
+ String cname = getClass().getName();
+
+ timeFormat = manager.getProperty(cname + ".timeFormat");
+
+ if (timeFormat == null)
+ {
+ timeFormat = "dd-MMM-yyy; HH:mm:ss";
+ }
+ setTimeFormat(timeFormat);
+
+ logPattern = manager.getProperty(cname + ".logPattern");
+ if (logPattern == null)
+ {
+ logPattern = "[{0} - {1}] {2}: {3} \n";
+ }
+ setLogPattern(logPattern);
+
+ exceptionPattern = manager.getProperty(cname + ".exceptionPattern");
+ if (exceptionPattern == null)
+ {
+ exceptionPattern = "[{0} - {1}] {2} {3} \nException in {4}: {6} \n{7} ";
+ }
+ setExceptionPattern(exceptionPattern);
+
+ logMessageFormat = new MessageFormat(logPattern);
+ exceptionMessageFormat = new MessageFormat(exceptionPattern);
+
+ dateFormat = new SimpleDateFormat(timeFormat);
+ }
+
+ /**
+ * Sets the time format.
+ *
+ * @param timeFormat
+ * the new time format
+ */
+ public void setTimeFormat(String timeFormat)
+ {
+ this.timeFormat = timeFormat;
+ dateFormat = new SimpleDateFormat(timeFormat);
+ }
+
+ /**
+ * Sets the log pattern.
+ *
+ * @param logFormat
+ * the new log pattern
+ */
+ public void setLogPattern(String logFormat)
+ {
+ logFormat = logFormat.replace("%LOGGER%", "{0}");
+ logFormat = logFormat.replace("%LEVEL%", "{1}");
+ logFormat = logFormat.replace("%TIME%", "{2}");
+ logFormat = logFormat.replace("%MESSAGE%", "{3}");
+ logFormat = logFormat.replace("%SOURCECLASS%", "{4}");
+ logFormat = logFormat.replace("%SOURCEMETHOD%", "{5}");
+ logFormat = logFormat.replace("%PARAM0%", "{6}");
+ logFormat = logFormat.replace("%PARAM1%", "{7}");
+
+ this.logPattern = logFormat;
+
+ logMessageFormat = new MessageFormat(logPattern);
+ }
+
+ /**
+ * Sets the exception pattern.
+ *
+ * @param exceptionFormat
+ * the new exception pattern
+ */
+ public void setExceptionPattern(String exceptionFormat)
+ {
+ exceptionFormat = exceptionFormat.replace("%LOGGER%", "{0}");
+ exceptionFormat = exceptionFormat.replace("%LEVEL%", "{1}");
+ exceptionFormat = exceptionFormat.replace("%TIME%", "{2}");
+ exceptionFormat = exceptionFormat.replace("%MESSAGE%", "{3}");
+ exceptionFormat = exceptionFormat.replace("%SOURCECLASS%", "{4}");
+ exceptionFormat = exceptionFormat.replace("%SOURCEMETHOD%", "{5}");
+ exceptionFormat = exceptionFormat.replace("%EXCEPTION%", "{6}");
+ exceptionFormat = exceptionFormat.replace("%STACKTRACE%", "{7}");
+
+ this.exceptionPattern = exceptionFormat;
+
+ exceptionMessageFormat = new MessageFormat(logPattern);
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.util.logging.Formatter#format(java.util.logging.LogRecord)
+ */
+ @Override
+ public String format(LogRecord record)
+ {
+ Date time = new Date(record.getMillis());
+ String formattedTime = dateFormat.format(time);
+
+ String logMessage = "";
+
+ if (record.getThrown() == null)
+ {
+ Object[] log =
+ { record.getLoggerName(), record.getLevel(), formattedTime, record.getMessage(), record.getSourceClassName(),
+ record.getSourceMethodName(), record.getParameters() == null ? "" : record.getParameters()[0], record.getParameters() == null ? "" : record.getParameters()[1] };
+
+ logMessage = logMessageFormat.format(log);
+ }
+ else
+ {
+ String stack = getStackLayout(record.getThrown(), "");
+
+ Object[] log =
+ { record.getLoggerName(), record.getLevel(), formattedTime, record.getMessage(), record.getSourceClassName(),
+ record.getSourceMethodName(), record.getThrown().getMessage(), stack };
+
+ logMessage = exceptionMessageFormat.format(log);
+ }
+ return logMessage;
+ }
+
+ /**
+ * Gets the stack layout.
+ *
+ * @param t
+ * the t
+ * @param indenter
+ * the indenter
+ *
+ * @return the stack layout
+ */
+ private String getStackLayout(Throwable t, String indenter)
+ {
+ indenter = indenter + " ";
+
+ StackTraceElement[] ste = t.getStackTrace();
+ String stack = indenter + ste[0].toString();
+ for (int i = 1; i < ste.length; i++)
+ {
+ stack = stack + "\n" + indenter + ste[i];
+ }
+
+ String innerStack = "";
+ if (t.getCause() != null)
+ {
+ innerStack = indenter + "Caused by: " + t.getCause().getMessage() + "\n";
+ innerStack = innerStack + getStackLayout(t.getCause(), indenter);
+ }
+ stack = stack + "\n" + innerStack;
+
+ return stack;
+ }
+
+ /**
+ * Gets the exception pattern.
+ *
+ * @return the exception pattern
+ */
+ public String getExceptionPattern()
+ {
+ return exceptionPattern;
+ }
+
+ /**
+ * Gets the log pattern.
+ *
+ * @return the log pattern
+ */
+ public String getLogPattern()
+ {
+ return logPattern;
+ }
+
+ /**
+ * Gets the time format.
+ *
+ * @return the time format
+ */
+ public String getTimeFormat()
+ {
+ return timeFormat;
+ }
+
+}
diff --git a/javaUtilities/yajsw/src/build/java/org/rzo/builder/JarBuilder.java b/javaUtilities/yajsw/src/build/java/org/rzo/builder/JarBuilder.java
new file mode 100644
index 0000000000..ea1eb8d8f7
--- /dev/null
+++ b/javaUtilities/yajsw/src/build/java/org/rzo/builder/JarBuilder.java
@@ -0,0 +1,140 @@
+package org.rzo.builder;
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipOutputStream;
+
+import org.apache.commons.vfs2.FileObject;
+import org.apache.commons.vfs2.FileSystemManager;
+import org.apache.commons.vfs2.VFS;
+import org.rzo.yajsw.util.VFSUtils;
+
+/**
+ *
+ * compress multiple jar files into a single jar file
+ *
+ * 1. run a program with -verbose:class, so that all required classes are loaded and logged
+ * 2. write log to a file
+ * 3. call java JarBuilder log-file newjar
+ *
+ * JarBuilder will build a jar with the files used by the application
+ *
+ */
+
+public class JarBuilder
+{
+ // multimap: assignment of jar files to class files used in the application
+ Map> _jar2class = new HashMap>();
+
+ // populate jar2class
+ private void parseLog(String file) throws IOException
+ {
+ InputStream in = new FileInputStream(file);
+ // -verbose:class logs have the pattern [Loaded from file:/]
+ Pattern p = Pattern.compile("\\[Loaded\\s(.*)\\s+from file\\:/(.*)\\]");
+ BufferedReader reader = new BufferedReader(new InputStreamReader(in));
+ String line = null;
+ try
+ {
+ while ((line = reader.readLine()) != null)
+ {
+ Matcher m = p.matcher(line);
+ if (m.find())
+ {
+ String clazz = m.group(1);
+ String jar = m.group(2);
+ // TODO do not add java classes
+ if (!jar.endsWith("/rt.jar"))
+ addClazz(jar, clazz);
+ }
+ }
+ }
+ catch (IOException e)
+ {
+ e.printStackTrace();
+ }
+ }
+
+ // add an entry to the multimap
+ private void addClazz(String jar, String clazz)
+ {
+ Set clazzes = _jar2class.get(jar);
+ System.out.println("add "+jar+"!"+clazz);
+ if (clazzes == null)
+ {
+ clazzes = new HashSet();
+ _jar2class.put(jar, clazzes);
+ }
+ clazzes.add(clazz);
+ }
+
+ // add a file to the destination jar
+ private void addFile(FileObject f, String name, ZipOutputStream out) throws IOException
+ {
+ InputStream in = f.getContent().getInputStream();
+ out.putNextEntry(new ZipEntry(name));
+
+ byte[] buf = new byte[1024];
+ int len;
+ while ((len = in.read(buf)) > 0) {
+ out.write(buf, 0, len);
+ }
+ // Complete the entry
+ out.closeEntry();
+ in.close();
+ }
+
+ // build the jar
+ // VFS currently does not support building zip files -> use java's ZipOutputStream
+ private void buildJar(String newJar) throws IOException
+ {
+ ZipOutputStream out = new ZipOutputStream(new FileOutputStream(newJar ));
+ FileSystemManager fsManager = VFS.getManager();
+ for (String jar : _jar2class.keySet())
+ {
+ FileObject jarFile;
+ if (jar.endsWith(".jar"))
+ jarFile = fsManager.resolveFile( "jar:"+jar );
+ else
+ jarFile = fsManager.resolveFile( jar );
+
+ for (String file : _jar2class.get(jar))
+ {
+ file = file.replaceAll("\\.", "/");
+ file += ".class";
+ FileObject f = fsManager.resolveFile(jarFile, file);
+ if (f.exists())
+ addFile(f, file, out);
+ else
+ System.out.println("file not found "+f);
+ }
+
+ }
+ out.close();
+ }
+
+
+ public static void main(String[] args) throws Exception
+ {
+ String logFile = args[0];
+ String newJar = args[1];
+ new File(newJar).delete();
+ JarBuilder b = new JarBuilder();
+ b.parseLog(logFile);
+ b.buildJar(newJar);
+
+ }
+
+}
diff --git a/javaUtilities/yajsw/src/build/java/org/rzo/builder/PolicyFileBuilder.java b/javaUtilities/yajsw/src/build/java/org/rzo/builder/PolicyFileBuilder.java
new file mode 100644
index 0000000000..127bb9ac69
--- /dev/null
+++ b/javaUtilities/yajsw/src/build/java/org/rzo/builder/PolicyFileBuilder.java
@@ -0,0 +1,6 @@
+package org.rzo.builder;
+
+public class PolicyFileBuilder
+{
+
+}
diff --git a/javaUtilities/yajsw/src/build/java/secmgr/manager/ProfilingSecurityManager.java b/javaUtilities/yajsw/src/build/java/secmgr/manager/ProfilingSecurityManager.java
new file mode 100644
index 0000000000..e722417c7b
--- /dev/null
+++ b/javaUtilities/yajsw/src/build/java/secmgr/manager/ProfilingSecurityManager.java
@@ -0,0 +1,241 @@
+/*
+
+ * Copyright (c) 2006 Mark Petrovic
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Original Author: Mark Petrovic
+ *
+*/
+
+package secmgr.manager;
+
+import static java.lang.System.err;
+import static java.lang.System.out;
+
+import java.lang.reflect.Field;
+
+import java.net.URL;
+
+import java.security.AccessController;
+import java.security.AccessControlContext;
+import java.security.CodeSource;
+import java.security.Permission;
+import java.security.ProtectionDomain;
+
+import java.util.ArrayList;
+
+/**
+ * ProfilingSecurityManager is a Java security manager that profiles
+ * what resources an application accesses, and in what manner --- e.g., read, write, etc. It does not enforce a
+ * security policy, but rather produces a starting point for crafting one.
+ *
+ * It extends java.lang.SecurityManager and overrides the two forms of the checkPermission() method.
+ * For each call to checkPermission(), ProfilingSecurityManager first guards against the
+ * condition that it itself induced the call to checkPermission(), which would result in
+ * unterminated recursion. If a call to checkPermission() resulted from a call outside
+ * ProfilingSecurityManager, the current context is examined and each class found therein is
+ * profiled as needing access to the java.security.Permission in question.
+ *
+ * Profiling is manifested as a writing to System.out a "grant" rule for each java.security.Permission requested
+ * on a per CodeBase basis.
+ *
+ * The implementation here does some very simple rule caching. If a rule has been seen previously, it is not output to System.out.
+ * The caching cannot prevent a security check, but it can reduce I/O during profiling.
+ *
+ * @author Mark S. Petrovic
+ */
+public class ProfilingSecurityManager extends SecurityManager {
+
+ /* Variables of pure convenience */
+ final private String thisClassName;
+ final private String thisCodeSourceURLString;
+ final private String psmMsg = "ProfilingSecurityManager";
+ final private ArrayList cacheList = new ArrayList();
+
+ // ---------------------------------
+
+ public ProfilingSecurityManager() {
+ thisClassName=this.getClass().getName();
+ CodeSource thisCodeSource = this.getClass().getProtectionDomain().getCodeSource();
+ thisCodeSourceURLString = thisCodeSource.getLocation().toString();
+ }
+
+ // -----------------
+
+ @Override
+ public void checkPermission(final Permission permission) {
+ final Throwable t = new Throwable("Profiler stack probe");
+ final StackTraceElement[] stack = t.getStackTrace();
+ // Avoid recursion owing to actions in this class itself inducing callbacks
+ if( !isRecur(stack) ) {
+ buildRules(permission, AccessController.getContext());
+ }
+ }
+
+ // -----------------
+
+ @Override
+ public void checkPermission(final Permission permission, final Object context) {
+ buildRules(permission, (AccessControlContext)context);
+ }
+
+ // -----------------
+
+ // With a Permission and an AccessControlContext, we can build and print rules
+ private void buildRules(final Permission permission, final AccessControlContext ctx) {
+ try {
+ final ProtectionDomain[] protectionDomain = getProtectionDomains(ctx);
+ if( null != protectionDomain ) {
+ for(int i=0;i=1;--i) {
+ final boolean c = st[i].getClassName().equals(thisClassName);
+ final boolean m = st[i].getMethodName().equals("buildRules");
+ if (c && m) {
+ v = true;
+ break;
+ }
+ }
+ return v;
+ }
+
+ // -----------------
+
+ /* Get the protection domains by Java reflection. There is no public API for this info,
+ * making this code Sun Java 1.5 JVM implementation dependent.
+ */
+ private ProtectionDomain[] getProtectionDomains(final AccessControlContext context) throws
+ IllegalStateException {
+ ProtectionDomain[] pda = null;
+ try {
+ final Field[] fields = AccessControlContext.class.getDeclaredFields();
+ if( null == fields ) {
+ throw new IllegalStateException("No fields");
+ }
+ for(int i=0; i
+ * java.api.class - the Java interface for the object interface.
+ * java.ejb.home.class - the EJB home interface
+ * java.ejb.remote.class - the EJB remote interface
+ * java.primary.key.class - the EJB primary key class
+ *
+ */
+ public Object _hessian_getAttribute(String name);
+}
diff --git a/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/client/HessianProxy.java b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/client/HessianProxy.java
new file mode 100644
index 0000000000..bdfe9dafa8
--- /dev/null
+++ b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/client/HessianProxy.java
@@ -0,0 +1,472 @@
+/*
+ * The Apache Software License, Version 1.1
+ *
+ * Copyright (c) 2001-2004 Caucho Technology, Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. 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.
+ *
+ * 3. The end-user documentation included with the redistribution, if
+ * any, must include the following acknowlegement:
+ * "This product includes software developed by the
+ * Caucho Technology (http://www.caucho.com/)."
+ * Alternately, this acknowlegement may appear in the software itself,
+ * if and wherever such third-party acknowlegements normally appear.
+ *
+ * 4. The names "Hessian", "Resin", and "Caucho" must not be used to
+ * endorse or promote products derived from this software without prior
+ * written permission. For written permission, please contact
+ * info@caucho.com.
+ *
+ * 5. Products derived from this software may not be called "Resin"
+ * nor may "Resin" appear in their names without prior written
+ * permission of Caucho Technology.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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 CAUCHO TECHNOLOGY OR ITS 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.
+ *
+ * @author Scott Ferguson
+ */
+
+package com.caucho.hessian4.client;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.PrintWriter;
+import java.io.Serializable;
+import java.io.Writer;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.net.URL;
+import java.net.URLConnection;
+import java.util.WeakHashMap;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import com.caucho.hessian4.io.AbstractHessianInput;
+import com.caucho.hessian4.io.AbstractHessianOutput;
+import com.caucho.hessian4.io.HessianDebugInputStream;
+import com.caucho.hessian4.io.HessianDebugOutputStream;
+import com.caucho.hessian4.io.HessianProtocolException;
+import com.caucho.hessian4.io.HessianRemote;
+import com.caucho.hessian4.services.server.AbstractSkeleton;
+
+/**
+ * Proxy implementation for Hessian clients. Applications will generally
+ * use HessianProxyFactory to create proxy clients.
+ */
+public class HessianProxy implements InvocationHandler, Serializable {
+ private static final Logger log
+ = Logger.getLogger(HessianProxy.class.getName());
+
+ protected HessianProxyFactory _factory;
+
+ private WeakHashMap _mangleMap
+ = new WeakHashMap();
+
+ private Class _type;
+ private URL _url;
+
+ /**
+ * Protected constructor for subclassing
+ */
+ protected HessianProxy(URL url, HessianProxyFactory factory)
+ {
+ this(url, factory, null);
+ }
+
+ /**
+ * Protected constructor for subclassing
+ */
+ protected HessianProxy(URL url,
+ HessianProxyFactory factory,
+ Class type)
+ {
+ _factory = factory;
+ _url = url;
+ _type = type;
+ }
+
+ /**
+ * Returns the proxy's URL.
+ */
+ public URL getURL()
+ {
+ return _url;
+ }
+
+ /**
+ * Handles the object invocation.
+ *
+ * @param proxy the proxy object to invoke
+ * @param method the method to call
+ * @param args the arguments to the proxy object
+ */
+ public Object invoke(Object proxy, Method method, Object []args)
+ throws Throwable
+ {
+ String mangleName;
+
+ synchronized (_mangleMap) {
+ mangleName = _mangleMap.get(method);
+ }
+
+ if (mangleName == null) {
+ String methodName = method.getName();
+ Class []params = method.getParameterTypes();
+
+ // equals and hashCode are special cased
+ if (methodName.equals("equals")
+ && params.length == 1 && params[0].equals(Object.class)) {
+ Object value = args[0];
+ if (value == null || ! Proxy.isProxyClass(value.getClass()))
+ return Boolean.FALSE;
+
+ Object proxyHandler = Proxy.getInvocationHandler(value);
+
+ if (! (proxyHandler instanceof HessianProxy))
+ return Boolean.FALSE;
+
+ HessianProxy handler = (HessianProxy) proxyHandler;
+
+ return new Boolean(_url.equals(handler.getURL()));
+ }
+ else if (methodName.equals("hashCode") && params.length == 0)
+ return new Integer(_url.hashCode());
+ else if (methodName.equals("getHessianType"))
+ return proxy.getClass().getInterfaces()[0].getName();
+ else if (methodName.equals("getHessianURL"))
+ return _url.toString();
+ else if (methodName.equals("toString") && params.length == 0)
+ return "HessianProxy[" + _url + "]";
+
+ if (! _factory.isOverloadEnabled())
+ mangleName = method.getName();
+ else
+ mangleName = mangleName(method);
+
+ synchronized (_mangleMap) {
+ _mangleMap.put(method, mangleName);
+ }
+ }
+
+ InputStream is = null;
+ HessianConnection conn = null;
+
+ try {
+ if (log.isLoggable(Level.FINER))
+ log.finer("Hessian[" + _url + "] calling " + mangleName);
+
+ conn = sendRequest(mangleName, args);
+
+ is = conn.getInputStream();
+
+ if (log.isLoggable(Level.FINEST)) {
+ PrintWriter dbg = new PrintWriter(new LogWriter(log));
+ HessianDebugInputStream dIs
+ = new HessianDebugInputStream(is, dbg);
+
+ dIs.startTop2();
+
+ is = dIs;
+ }
+
+ AbstractHessianInput in;
+
+ int code = is.read();
+
+ if (code == 'H') {
+ int major = is.read();
+ int minor = is.read();
+
+ in = _factory.getHessian2Input(is);
+
+ Object value = in.readReply(method.getReturnType());
+
+ return value;
+ }
+ else if (code == 'r') {
+ int major = is.read();
+ int minor = is.read();
+
+ in = _factory.getHessianInput(is);
+
+ in.startReplyBody();
+
+ Object value = in.readObject(method.getReturnType());
+
+ if (value instanceof InputStream) {
+ value = new ResultInputStream(conn, is, in, (InputStream) value);
+ is = null;
+ conn = null;
+ }
+ else
+ in.completeReply();
+
+ return value;
+ }
+ else
+ throw new HessianProtocolException("'" + (char) code + "' is an unknown code");
+ } catch (HessianProtocolException e) {
+ throw new HessianRuntimeException(e);
+ } finally {
+ try {
+ if (is != null)
+ is.close();
+ } catch (Exception e) {
+ log.log(Level.FINE, e.toString(), e);
+ }
+
+ try {
+ if (conn != null)
+ conn.destroy();
+ } catch (Exception e) {
+ log.log(Level.FINE, e.toString(), e);
+ }
+ }
+ }
+
+ protected String mangleName(Method method)
+ {
+ Class []param = method.getParameterTypes();
+
+ if (param == null || param.length == 0)
+ return method.getName();
+ else
+ return AbstractSkeleton.mangleName(method, false);
+ }
+
+ /**
+ * Sends the HTTP request to the Hessian connection.
+ */
+ protected HessianConnection sendRequest(String methodName, Object []args)
+ throws IOException
+ {
+ HessianConnection conn = null;
+
+ conn = _factory.getConnectionFactory().open(_url);
+ boolean isValid = false;
+
+ try {
+ addRequestHeaders(conn);
+
+ OutputStream os = null;
+
+ try {
+ os = conn.getOutputStream();
+ } catch (Exception e) {
+ throw new HessianRuntimeException(e);
+ }
+
+ if (log.isLoggable(Level.FINEST)) {
+ PrintWriter dbg = new PrintWriter(new LogWriter(log));
+ HessianDebugOutputStream dOs = new HessianDebugOutputStream(os, dbg);
+ dOs.startTop2();
+ os = dOs;
+ }
+
+ AbstractHessianOutput out = _factory.getHessianOutput(os);
+
+ out.call(methodName, args);
+ out.flush();
+
+ conn.sendRequest();
+
+ isValid = true;
+
+ return conn;
+ } finally {
+ if (! isValid && conn != null)
+ conn.destroy();
+ }
+ }
+
+ /**
+ * Method that allows subclasses to add request headers such as cookies.
+ * Default implementation is empty.
+ */
+ protected void addRequestHeaders(HessianConnection conn)
+ {
+ conn.addHeader("Content-Type", "x-application/hessian");
+
+ String basicAuth = _factory.getBasicAuth();
+
+ if (basicAuth != null)
+ conn.addHeader("Authorization", basicAuth);
+ }
+
+ /**
+ * Method that allows subclasses to parse response headers such as cookies.
+ * Default implementation is empty.
+ * @param conn
+ */
+ protected void parseResponseHeaders(URLConnection conn)
+ {
+ }
+
+ public Object writeReplace()
+ {
+ return new HessianRemote(_type.getName(), _url.toString());
+ }
+
+ static class ResultInputStream extends InputStream {
+ private HessianConnection _conn;
+ private InputStream _connIs;
+ private AbstractHessianInput _in;
+ private InputStream _hessianIs;
+
+ ResultInputStream(HessianConnection conn,
+ InputStream is,
+ AbstractHessianInput in,
+ InputStream hessianIs)
+ {
+ _conn = conn;
+ _connIs = is;
+ _in = in;
+ _hessianIs = hessianIs;
+ }
+
+ public int read()
+ throws IOException
+ {
+ if (_hessianIs != null) {
+ int value = _hessianIs.read();
+
+ if (value < 0)
+ close();
+
+ return value;
+ }
+ else
+ return -1;
+ }
+
+ public int read(byte []buffer, int offset, int length)
+ throws IOException
+ {
+ if (_hessianIs != null) {
+ int value = _hessianIs.read(buffer, offset, length);
+
+ if (value < 0)
+ close();
+
+ return value;
+ }
+ else
+ return -1;
+ }
+
+ public void close()
+ throws IOException
+ {
+ HessianConnection conn = _conn;
+ _conn = null;
+
+ InputStream connIs = _connIs;
+ _connIs = null;
+
+ AbstractHessianInput in = _in;
+ _in = null;
+
+ InputStream hessianIs = _hessianIs;
+ _hessianIs = null;
+
+ try {
+ if (hessianIs != null)
+ hessianIs.close();
+ } catch (Exception e) {
+ log.log(Level.FINE, e.toString(), e);
+ }
+
+ try {
+ if (in != null) {
+ in.completeReply();
+ in.close();
+ }
+ } catch (Exception e) {
+ log.log(Level.FINE, e.toString(), e);
+ }
+
+ try {
+ if (connIs != null) {
+ connIs.close();
+ }
+ } catch (Exception e) {
+ log.log(Level.FINE, e.toString(), e);
+ }
+
+ try {
+ if (conn != null) {
+ conn.close();
+ }
+ } catch (Exception e) {
+ log.log(Level.FINE, e.toString(), e);
+ }
+ }
+ }
+
+ static class LogWriter extends Writer {
+ private Logger _log;
+ private Level _level = Level.FINEST;
+ private StringBuilder _sb = new StringBuilder();
+
+ LogWriter(Logger log)
+ {
+ _log = log;
+ }
+
+ public void write(char ch)
+ {
+ if (ch == '\n' && _sb.length() > 0) {
+ _log.fine(_sb.toString());
+ _sb.setLength(0);
+ }
+ else
+ _sb.append((char) ch);
+ }
+
+ public void write(char []buffer, int offset, int length)
+ {
+ for (int i = 0; i < length; i++) {
+ char ch = buffer[offset + i];
+
+ if (ch == '\n' && _sb.length() > 0) {
+ _log.log(_level, _sb.toString());
+ _sb.setLength(0);
+ }
+ else
+ _sb.append((char) ch);
+ }
+ }
+
+ public void flush()
+ {
+ }
+
+ public void close()
+ {
+ if (_sb.length() > 0)
+ _log.log(_level, _sb.toString());
+ }
+ }
+}
diff --git a/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/client/HessianProxyFactory.java b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/client/HessianProxyFactory.java
new file mode 100644
index 0000000000..e125d4e1f2
--- /dev/null
+++ b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/client/HessianProxyFactory.java
@@ -0,0 +1,607 @@
+/*
+ * The Apache Software License, Version 1.1
+ *
+ * Copyright (c) 2001-2004 Caucho Technology, Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. 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.
+ *
+ * 3. The end-user documentation included with the redistribution, if
+ * any, must include the following acknowlegement:
+ * "This product includes software developed by the
+ * Caucho Technology (http://www.caucho.com/)."
+ * Alternately, this acknowlegement may appear in the software itself,
+ * if and wherever such third-party acknowlegements normally appear.
+ *
+ * 4. The names "Hessian", "Resin", and "Caucho" must not be used to
+ * endorse or promote products derived from this software without prior
+ * written permission. For written permission, please contact
+ * info@caucho.com.
+ *
+ * 5. Products derived from this software may not be called "Resin"
+ * nor may "Resin" appear in their names without prior written
+ * permission of Caucho Technology.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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 CAUCHO TECHNOLOGY OR ITS 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.
+ *
+ * @author Scott Ferguson
+ */
+
+package com.caucho.hessian4.client;
+
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.PrintWriter;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Proxy;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.util.logging.Logger;
+
+import com.caucho.hessian4.io.AbstractHessianInput;
+import com.caucho.hessian4.io.AbstractHessianOutput;
+import com.caucho.hessian4.io.Hessian2Input;
+import com.caucho.hessian4.io.Hessian2Output;
+import com.caucho.hessian4.io.HessianDebugInputStream;
+import com.caucho.hessian4.io.HessianInput;
+import com.caucho.hessian4.io.HessianOutput;
+import com.caucho.hessian4.io.HessianRemoteObject;
+import com.caucho.hessian4.io.HessianRemoteResolver;
+import com.caucho.hessian4.io.SerializerFactory;
+import com.caucho.hessian4.services.client.ServiceProxyFactory;
+
+/**
+ * Factory for creating Hessian client stubs. The returned stub will
+ * call the remote object for all methods.
+ *
+ *
+ * String url = "http://localhost:8080/ejb/hello";
+ * HelloHome hello = (HelloHome) factory.create(HelloHome.class, url);
+ *
+ *
+ * After creation, the stub can be like a regular Java class. Because
+ * it makes remote calls, it can throw more exceptions than a Java class.
+ * In particular, it may throw protocol exceptions.
+ *
+ * The factory can also be configured as a JNDI resource. The factory
+ * expects to parameters: "type" and "url", corresponding to the two
+ * arguments to create
+ *
+ * In Resin 3.0, the above example would be configured as:
+ *
+ * <reference>
+ * <jndi-name>hessian/hello</jndi-name>
+ * <factory>com.caucho.hessian.client.HessianProxyFactory</factory>
+ * <init-param url="http://localhost:8080/ejb/hello"/>
+ * <init-param type="test.HelloHome"/>
+ * </reference>
+ *
+ *
+ * To get the above resource, use JNDI as follows:
+ *
+ * Context ic = new InitialContext();
+ * HelloHome hello = (HelloHome) ic.lookup("java:comp/env/hessian/hello");
+ *
+ * System.out.println("Hello: " + hello.helloWorld());
+ *
+ *
+ * Authentication
+ *
+ * The proxy can use HTTP basic authentication if the user and the
+ * password are set.
+ */
+public class HessianProxyFactory implements ServiceProxyFactory /*, ObjectFactory */{
+ protected static Logger log
+ = Logger.getLogger(HessianProxyFactory.class.getName());
+
+ private final ClassLoader _loader;
+
+ private SerializerFactory _serializerFactory;
+
+ private HessianConnectionFactory _connFactory;
+
+ private HessianRemoteResolver _resolver;
+
+ private String _user;
+ private String _password;
+ private String _basicAuth;
+
+ private boolean _isOverloadEnabled = false;
+
+ private boolean _isHessian2Reply = true;
+ private boolean _isHessian2Request = false;
+
+ private boolean _isChunkedPost = true;
+ private boolean _isDebug = false;
+
+ private long _readTimeout = -1;
+ private long _connectTimeout = -1;
+
+ /**
+ * Creates the new proxy factory.
+ */
+ public HessianProxyFactory()
+ {
+ this(Thread.currentThread().getContextClassLoader());
+ }
+
+ /**
+ * Creates the new proxy factory.
+ */
+ public HessianProxyFactory(ClassLoader loader)
+ {
+ _loader = loader;
+ _resolver = new HessianProxyResolver(this);
+ }
+
+ /**
+ * Sets the user.
+ */
+ public void setUser(String user)
+ {
+ _user = user;
+ _basicAuth = null;
+ }
+
+ /**
+ * Sets the password.
+ */
+ public void setPassword(String password)
+ {
+ _password = password;
+ _basicAuth = null;
+ }
+
+ public String getBasicAuth()
+ {
+ if (_basicAuth != null)
+ return _basicAuth;
+
+ else if (_user != null && _password != null)
+ return "Basic " + base64(_user + ":" + _password);
+
+ else
+ return null;
+ }
+
+ /**
+ * Sets the connection factory to use when connecting
+ * to the Hessian service.
+ */
+ public void setConnectionFactory(HessianConnectionFactory factory)
+ {
+ _connFactory = factory;
+ }
+
+ /**
+ * Returns the connection factory to be used for the HTTP request.
+ */
+ public HessianConnectionFactory getConnectionFactory()
+ {
+ if (_connFactory == null) {
+ _connFactory = createHessianConnectionFactory();
+ _connFactory.setHessianProxyFactory(this);
+ }
+
+ return _connFactory;
+ }
+
+ /**
+ * Sets the debug
+ */
+ public void setDebug(boolean isDebug)
+ {
+ _isDebug = isDebug;
+ }
+
+ /**
+ * Gets the debug
+ */
+ public boolean isDebug()
+ {
+ return _isDebug;
+ }
+
+ /**
+ * Returns true if overloaded methods are allowed (using mangling)
+ */
+ public boolean isOverloadEnabled()
+ {
+ return _isOverloadEnabled;
+ }
+
+ /**
+ * set true if overloaded methods are allowed (using mangling)
+ */
+ public void setOverloadEnabled(boolean isOverloadEnabled)
+ {
+ _isOverloadEnabled = isOverloadEnabled;
+ }
+
+ /**
+ * Set true if should use chunked encoding on the request.
+ */
+ public void setChunkedPost(boolean isChunked)
+ {
+ _isChunkedPost = isChunked;
+ }
+
+ /**
+ * Set true if should use chunked encoding on the request.
+ */
+ public boolean isChunkedPost()
+ {
+ return _isChunkedPost;
+ }
+
+ /**
+ * The socket timeout on requests in milliseconds.
+ */
+ public long getReadTimeout()
+ {
+ return _readTimeout;
+ }
+
+ /**
+ * The socket timeout on requests in milliseconds.
+ */
+ public void setReadTimeout(long timeout)
+ {
+ _readTimeout = timeout;
+ }
+
+ /**
+ * The socket connection timeout in milliseconds.
+ */
+ public long getConnectTimeout()
+ {
+ return _connectTimeout;
+ }
+
+ /**
+ * The socket connect timeout in milliseconds.
+ */
+ public void setConnectTimeout(long timeout)
+ {
+ _connectTimeout = timeout;
+ }
+
+ /**
+ * True if the proxy can read Hessian 2 responses.
+ */
+ public void setHessian2Reply(boolean isHessian2)
+ {
+ _isHessian2Reply = isHessian2;
+ }
+
+ /**
+ * True if the proxy should send Hessian 2 requests.
+ */
+ public void setHessian2Request(boolean isHessian2)
+ {
+ _isHessian2Request = isHessian2;
+
+ if (isHessian2)
+ _isHessian2Reply = true;
+ }
+
+ /**
+ * Returns the remote resolver.
+ */
+ public HessianRemoteResolver getRemoteResolver()
+ {
+ return _resolver;
+ }
+
+ /**
+ * Sets the serializer factory.
+ */
+ public void setSerializerFactory(SerializerFactory factory)
+ {
+ _serializerFactory = factory;
+ }
+
+ /**
+ * Gets the serializer factory.
+ */
+ public SerializerFactory getSerializerFactory()
+ {
+ if (_serializerFactory == null)
+ _serializerFactory = new SerializerFactory(_loader);
+
+ return _serializerFactory;
+ }
+
+ protected HessianConnectionFactory createHessianConnectionFactory()
+ {
+ String className
+ = System.getProperty(HessianConnectionFactory.class.getName());
+
+ HessianConnectionFactory factory = null;
+
+ try {
+ if (className != null) {
+ ClassLoader loader = Thread.currentThread().getContextClassLoader();
+
+ Class cl = Class.forName(className, false, loader);
+
+ factory = (HessianConnectionFactory) cl.newInstance();
+
+ return factory;
+ }
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+
+ return new HessianURLConnectionFactory();
+ }
+ /**
+ * Creates a new proxy with the specified URL. The API class uses
+ * the java.api.class value from _hessian_
+ *
+ * @param url the URL where the client object is located.
+ *
+ * @return a proxy to the object with the specified interface.
+ */
+ public Object create(String url)
+ throws MalformedURLException, ClassNotFoundException
+ {
+ HessianMetaInfoAPI metaInfo;
+
+ metaInfo = (HessianMetaInfoAPI) create(HessianMetaInfoAPI.class, url);
+
+ String apiClassName =
+ (String) metaInfo._hessian_getAttribute("java.api.class");
+
+ if (apiClassName == null)
+ throw new HessianRuntimeException(url + " has an unknown api.");
+
+ Class apiClass = Class.forName(apiClassName, false, _loader);
+
+ return create(apiClass, url);
+ }
+
+ /**
+ * Creates a new proxy with the specified URL. The returned object
+ * is a proxy with the interface specified by api.
+ *
+ *
+ * String url = "http://localhost:8080/ejb/hello");
+ * HelloHome hello = (HelloHome) factory.create(HelloHome.class, url);
+ *
+ *
+ * @param api the interface the proxy class needs to implement
+ * @param url the URL where the client object is located.
+ *
+ * @return a proxy to the object with the specified interface.
+ */
+ public Object create(Class api, String urlName)
+ throws MalformedURLException
+ {
+ return create(api, urlName, _loader);
+ }
+
+ /**
+ * Creates a new proxy with the specified URL. The returned object
+ * is a proxy with the interface specified by api.
+ *
+ *
+ * String url = "http://localhost:8080/ejb/hello");
+ * HelloHome hello = (HelloHome) factory.create(HelloHome.class, url);
+ *
+ *
+ * @param api the interface the proxy class needs to implement
+ * @param url the URL where the client object is located.
+ *
+ * @return a proxy to the object with the specified interface.
+ */
+ public Object create(Class api, String urlName, ClassLoader loader)
+ throws MalformedURLException
+ {
+ URL url = new URL(urlName);
+
+ return create(api, url, loader);
+ }
+
+ /**
+ * Creates a new proxy with the specified URL. The returned object
+ * is a proxy with the interface specified by api.
+ *
+ *
+ * String url = "http://localhost:8080/ejb/hello");
+ * HelloHome hello = (HelloHome) factory.create(HelloHome.class, url);
+ *
+ *
+ * @param api the interface the proxy class needs to implement
+ * @param url the URL where the client object is located.
+ *
+ * @return a proxy to the object with the specified interface.
+ */
+ public Object create(Class api, URL url, ClassLoader loader)
+ {
+ if (api == null)
+ throw new NullPointerException("api must not be null for HessianProxyFactory.create()");
+ InvocationHandler handler = null;
+
+ handler = new HessianProxy(url, this, api);
+
+ return Proxy.newProxyInstance(loader,
+ new Class[] { api,
+ HessianRemoteObject.class },
+ handler);
+ }
+
+ public AbstractHessianInput getHessianInput(InputStream is)
+ {
+ return getHessian2Input(is);
+ }
+
+ public AbstractHessianInput getHessian1Input(InputStream is)
+ {
+ AbstractHessianInput in;
+
+ if (_isDebug)
+ is = new HessianDebugInputStream(is, new PrintWriter(System.out));
+
+ in = new HessianInput(is);
+
+ in.setRemoteResolver(getRemoteResolver());
+
+ in.setSerializerFactory(getSerializerFactory());
+
+ return in;
+ }
+
+ public AbstractHessianInput getHessian2Input(InputStream is)
+ {
+ AbstractHessianInput in;
+
+ if (_isDebug)
+ is = new HessianDebugInputStream(is, new PrintWriter(System.out));
+
+ in = new Hessian2Input(is);
+
+ in.setRemoteResolver(getRemoteResolver());
+
+ in.setSerializerFactory(getSerializerFactory());
+
+ return in;
+ }
+
+ public AbstractHessianOutput getHessianOutput(OutputStream os)
+ {
+ AbstractHessianOutput out;
+
+ if (_isHessian2Request)
+ out = new Hessian2Output(os);
+ else {
+ HessianOutput out1 = new HessianOutput(os);
+ out = out1;
+
+ if (_isHessian2Reply)
+ out1.setVersion(2);
+ }
+
+ out.setSerializerFactory(getSerializerFactory());
+
+ return out;
+ }
+
+// /**
+// * JNDI object factory so the proxy can be used as a resource.
+// */
+// public Object getObjectInstance(Object obj, Name name,
+// Context nameCtx, Hashtable environment)
+// throws Exception
+// {
+// Reference ref = (Reference) obj;
+//
+// String api = null;
+// String url = null;
+// String user = null;
+// String password = null;
+//
+// for (int i = 0; i < ref.size(); i++) {
+// RefAddr addr = ref.get(i);
+//
+// String type = addr.getType();
+// String value = (String) addr.getContent();
+//
+// if (type.equals("type"))
+// api = value;
+// else if (type.equals("url"))
+// url = value;
+// else if (type.equals("user"))
+// setUser(value);
+// else if (type.equals("password"))
+// setPassword(value);
+// }
+//
+// if (url == null)
+// throw new NamingException("`url' must be configured for HessianProxyFactory.");
+// // XXX: could use meta protocol to grab this
+// if (api == null)
+// throw new NamingException("`type' must be configured for HessianProxyFactory.");
+//
+// Class apiClass = Class.forName(api, false, _loader);
+//
+// return create(apiClass, url);
+// }
+
+ /**
+ * Creates the Base64 value.
+ */
+ private String base64(String value)
+ {
+ StringBuffer cb = new StringBuffer();
+
+ int i = 0;
+ for (i = 0; i + 2 < value.length(); i += 3) {
+ long chunk = (int) value.charAt(i);
+ chunk = (chunk << 8) + (int) value.charAt(i + 1);
+ chunk = (chunk << 8) + (int) value.charAt(i + 2);
+
+ cb.append(encode(chunk >> 18));
+ cb.append(encode(chunk >> 12));
+ cb.append(encode(chunk >> 6));
+ cb.append(encode(chunk));
+ }
+
+ if (i + 1 < value.length()) {
+ long chunk = (int) value.charAt(i);
+ chunk = (chunk << 8) + (int) value.charAt(i + 1);
+ chunk <<= 8;
+
+ cb.append(encode(chunk >> 18));
+ cb.append(encode(chunk >> 12));
+ cb.append(encode(chunk >> 6));
+ cb.append('=');
+ }
+ else if (i < value.length()) {
+ long chunk = (int) value.charAt(i);
+ chunk <<= 16;
+
+ cb.append(encode(chunk >> 18));
+ cb.append(encode(chunk >> 12));
+ cb.append('=');
+ cb.append('=');
+ }
+
+ return cb.toString();
+ }
+
+ public static char encode(long d)
+ {
+ d &= 0x3f;
+ if (d < 26)
+ return (char) (d + 'A');
+ else if (d < 52)
+ return (char) (d + 'a' - 26);
+ else if (d < 62)
+ return (char) (d + '0' - 52);
+ else if (d == 62)
+ return '+';
+ else
+ return '/';
+ }
+}
+
diff --git a/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/client/HessianProxyResolver.java b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/client/HessianProxyResolver.java
new file mode 100644
index 0000000000..047fde6fde
--- /dev/null
+++ b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/client/HessianProxyResolver.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) 2001-2004 Caucho Technology, Inc. All rights reserved.
+ *
+ * The Apache Software License, Version 1.1
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. 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.
+ *
+ * 3. The end-user documentation included with the redistribution, if
+ * any, must include the following acknowlegement:
+ * "This product includes software developed by the
+ * Caucho Technology (http://www.caucho.com/)."
+ * Alternately, this acknowlegement may appear in the software itself,
+ * if and wherever such third-party acknowlegements normally appear.
+ *
+ * 4. The names "Hessian", "Resin", and "Caucho" must not be used to
+ * endorse or promote products derived from this software without prior
+ * written permission. For written permission, please contact
+ * info@caucho.com.
+ *
+ * 5. Products derived from this software may not be called "Resin"
+ * nor may "Resin" appear in their names without prior written
+ * permission of Caucho Technology.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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 CAUCHO TECHNOLOGY OR ITS 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.
+ *
+ * @author Scott Ferguson
+ */
+
+package com.caucho.hessian4.client;
+
+import java.io.IOException;
+
+import com.caucho.hessian4.io.HessianRemoteResolver;
+
+/**
+ * Looks up remote objects in the proxy.
+ */
+public class HessianProxyResolver implements HessianRemoteResolver {
+ private HessianProxyFactory _factory;
+
+ /**
+ * Creates an uninitialized Hessian remote resolver.
+ */
+ public HessianProxyResolver(HessianProxyFactory factory)
+ {
+ _factory = factory;
+ }
+
+ /**
+ * Looks up a proxy object.
+ */
+ public Object lookup(String type, String url)
+ throws IOException
+ {
+ ClassLoader loader = Thread.currentThread().getContextClassLoader();
+
+ try {
+ Class api = Class.forName(type, false, loader);
+
+ return _factory.create(api, url);
+ } catch (Exception e) {
+ throw new IOException(String.valueOf(e));
+ }
+ }
+}
diff --git a/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/client/HessianRuntimeException.java b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/client/HessianRuntimeException.java
new file mode 100644
index 0000000000..a8f27a99ff
--- /dev/null
+++ b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/client/HessianRuntimeException.java
@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) 2001-2004 Caucho Technology, Inc. All rights reserved.
+ *
+ * The Apache Software License, Version 1.1
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. 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.
+ *
+ * 3. The end-user documentation included with the redistribution, if
+ * any, must include the following acknowlegement:
+ * "This product includes software developed by the
+ * Caucho Technology (http://www.caucho.com/)."
+ * Alternately, this acknowlegement may appear in the software itself,
+ * if and wherever such third-party acknowlegements normally appear.
+ *
+ * 4. The names "Hessian", "Resin", and "Caucho" must not be used to
+ * endorse or promote products derived from this software without prior
+ * written permission. For written permission, please contact
+ * info@caucho.com.
+ *
+ * 5. Products derived from this software may not be called "Resin"
+ * nor may "Resin" appear in their names without prior written
+ * permission of Caucho Technology.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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 CAUCHO TECHNOLOGY OR ITS 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.
+ *
+ * @author Scott Ferguson
+ */
+
+package com.caucho.hessian4.client;
+
+/**
+ * Wrapper for protocol exceptions thrown in the proxy.
+ */
+public class HessianRuntimeException extends RuntimeException {
+ private Throwable rootCause;
+
+ /**
+ * Zero-arg constructor.
+ */
+ public HessianRuntimeException()
+ {
+ }
+
+ /**
+ * Create the exception.
+ */
+ public HessianRuntimeException(String message)
+ {
+ super(message);
+ }
+
+ /**
+ * Create the exception.
+ */
+ public HessianRuntimeException(String message, Throwable rootCause)
+ {
+ super(message);
+
+ this.rootCause = rootCause;
+ }
+
+ /**
+ * Create the exception.
+ */
+ public HessianRuntimeException(Throwable rootCause)
+ {
+ super(String.valueOf(rootCause));
+
+ this.rootCause = rootCause;
+ }
+
+ /**
+ * Returns the underlying cause.
+ */
+ public Throwable getRootCause()
+ {
+ return this.rootCause;
+ }
+
+ /**
+ * Returns the underlying cause.
+ */
+ public Throwable getCause()
+ {
+ return getRootCause();
+ }
+}
diff --git a/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/client/HessianURLConnection.java b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/client/HessianURLConnection.java
new file mode 100644
index 0000000000..2ad61eba9c
--- /dev/null
+++ b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/client/HessianURLConnection.java
@@ -0,0 +1,203 @@
+/*
+ * Copyright (c) 2001-2004 Caucho Technology, Inc. All rights reserved.
+ *
+ * The Apache Software License, Version 1.1
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. 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.
+ *
+ * 3. The end-user documentation included with the redistribution, if
+ * any, must include the following acknowlegement:
+ * "This product includes software developed by the
+ * Caucho Technology (http://www.caucho.com/)."
+ * Alternately, this acknowlegement may appear in the software itself,
+ * if and wherever such third-party acknowlegements normally appear.
+ *
+ * 4. The names "Burlap", "Resin", and "Caucho" must not be used to
+ * endorse or promote products derived from this software without prior
+ * written permission. For written permission, please contact
+ * info@caucho.com.
+ *
+ * 5. Products derived from this software may not be called "Resin"
+ * nor may "Resin" appear in their names without prior written
+ * permission of Caucho Technology.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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 CAUCHO TECHNOLOGY OR ITS 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.
+ *
+ * @author Scott Ferguson
+ */
+
+package com.caucho.hessian4.client;
+
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.net.URLConnection;
+
+/**
+ * Internal connection to a server. The default connection is based on
+ * java.net
+ */
+public class HessianURLConnection extends AbstractHessianConnection {
+ private URL _url;
+ private URLConnection _conn;
+
+ private int _statusCode;
+ private String _statusMessage;
+
+ private InputStream _inputStream;
+ private InputStream _errorStream;
+
+ HessianURLConnection(URL url, URLConnection conn)
+ {
+ _url = url;
+ _conn = conn;
+ }
+
+ /**
+ * Adds a HTTP header.
+ */
+ public void addHeader(String key, String value)
+ {
+ _conn.setRequestProperty(key, value);
+ }
+
+ /**
+ * Returns the output stream for the request.
+ */
+ public OutputStream getOutputStream()
+ throws IOException
+ {
+ return _conn.getOutputStream();
+ }
+
+ /**
+ * Sends the request
+ */
+ public void sendRequest()
+ throws IOException
+ {
+ if (_conn instanceof HttpURLConnection) {
+ HttpURLConnection httpConn = (HttpURLConnection) _conn;
+
+ _statusCode = 500;
+
+ try {
+ _statusCode = httpConn.getResponseCode();
+ } catch (Exception e) {
+ }
+
+ parseResponseHeaders(httpConn);
+
+ InputStream is = null;
+
+ if (_statusCode != 200) {
+ StringBuffer sb = new StringBuffer();
+ int ch;
+
+ try {
+ is = httpConn.getInputStream();
+
+ if (is != null) {
+ while ((ch = is.read()) >= 0)
+ sb.append((char) ch);
+
+ is.close();
+ }
+
+ is = httpConn.getErrorStream();
+ if (is != null) {
+ while ((ch = is.read()) >= 0)
+ sb.append((char) ch);
+ }
+
+ _statusMessage = sb.toString();
+ } catch (FileNotFoundException e) {
+ throw new HessianConnectionException("HessianProxy cannot connect to '" + _url, e);
+ } catch (IOException e) {
+ if (is == null)
+ throw new HessianConnectionException(_statusCode + ": " + e, e);
+ else
+ throw new HessianConnectionException(_statusCode + ": " + sb, e);
+ }
+
+ if (is != null)
+ is.close();
+
+ throw new HessianConnectionException(_statusCode + ": " + sb.toString());
+ }
+ }
+ }
+
+ protected void parseResponseHeaders(HttpURLConnection conn)
+ throws IOException
+ {
+ }
+
+ /**
+ * Returns the status code.
+ */
+ public int getStatusCode()
+ {
+ return _statusCode;
+ }
+
+ /**
+ * Returns the status string.
+ */
+ public String getStatusMessage()
+ {
+ return _statusMessage;
+ }
+
+ /**
+ * Returns the InputStream to the result
+ */
+ public InputStream getInputStream()
+ throws IOException
+ {
+ return _conn.getInputStream();
+ }
+
+ /**
+ * Close/free the connection
+ */
+ public void close()
+ {
+ }
+
+ /**
+ * Disconnect the connection
+ */
+ public void destroy()
+ {
+ URLConnection conn = _conn;
+ _conn = null;
+
+ if (conn instanceof HttpURLConnection)
+ ((HttpURLConnection) conn).disconnect();
+ }
+}
+
diff --git a/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/client/HessianURLConnectionFactory.java b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/client/HessianURLConnectionFactory.java
new file mode 100644
index 0000000000..5665a9e3ba
--- /dev/null
+++ b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/client/HessianURLConnectionFactory.java
@@ -0,0 +1,117 @@
+/*
+ * Copyright (c) 2001-2004 Caucho Technology, Inc. All rights reserved.
+ *
+ * The Apache Software License, Version 1.1
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. 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.
+ *
+ * 3. The end-user documentation included with the redistribution, if
+ * any, must include the following acknowlegement:
+ * "This product includes software developed by the
+ * Caucho Technology (http://www.caucho.com/)."
+ * Alternately, this acknowlegement may appear in the software itself,
+ * if and wherever such third-party acknowlegements normally appear.
+ *
+ * 4. The names "Burlap", "Resin", and "Caucho" must not be used to
+ * endorse or promote products derived from this software without prior
+ * written permission. For written permission, please contact
+ * info@caucho.com.
+ *
+ * 5. Products derived from this software may not be called "Resin"
+ * nor may "Resin" appear in their names without prior written
+ * permission of Caucho Technology.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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 CAUCHO TECHNOLOGY OR ITS 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.
+ *
+ * @author Scott Ferguson
+ */
+
+package com.caucho.hessian4.client;
+
+import java.io.IOException;
+import java.net.URL;
+import java.net.URLConnection;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * Internal factory for creating connections to the server. The default
+ * factory is java.net
+ */
+public class HessianURLConnectionFactory implements HessianConnectionFactory {
+ private static final Logger log
+ = Logger.getLogger(HessianURLConnectionFactory.class.getName());
+
+ private HessianProxyFactory _proxyFactory;
+
+ public void setHessianProxyFactory(HessianProxyFactory factory)
+ {
+ _proxyFactory = factory;
+ }
+
+ /**
+ * Opens a new or recycled connection to the HTTP server.
+ */
+ public HessianConnection open(URL url)
+ throws IOException
+ {
+ if (log.isLoggable(Level.FINER))
+ log.finer(this + " open(" + url + ")");
+
+ URLConnection conn = url.openConnection();
+
+ // HttpURLConnection httpConn = (HttpURLConnection) conn;
+ // httpConn.setRequestMethod("POST");
+ // conn.setDoInput(true);
+
+ long connectTimeout = _proxyFactory.getConnectTimeout();
+
+ if (connectTimeout >= 0)
+ conn.setConnectTimeout((int) connectTimeout);
+
+ conn.setDoOutput(true);
+
+ long readTimeout = _proxyFactory.getReadTimeout();
+
+ if (readTimeout > 0) {
+ try {
+ conn.setReadTimeout((int) readTimeout);
+ } catch (Throwable e) {
+ }
+ }
+
+ /*
+ // Used chunked mode when available, i.e. JDK 1.5.
+ if (_proxyFactory.isChunkedPost() && conn instanceof HttpURLConnection) {
+ try {
+ HttpURLConnection httpConn = (HttpURLConnection) conn;
+
+ httpConn.setChunkedStreamingMode(8 * 1024);
+ } catch (Throwable e) {
+ }
+ }
+ */
+
+ return new HessianURLConnection(url, conn);
+ }
+}
diff --git a/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/client/package.html b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/client/package.html
new file mode 100644
index 0000000000..0b15710b98
--- /dev/null
+++ b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/client/package.html
@@ -0,0 +1,59 @@
+
+
+Portable client code for using Hessian services. Since this package is
+independent of all Resin code, its classes can be copied to a
+non-Resin client jar.
+
+RPC Proxy Clients - HessianProxyFactory
+
+Most application clients will use HessianProxyFactory to
+create stub objects. The stub objects can be called with normal
+Java calls. Because the objects are remote, the client application needs
+to be able to deal with IOException caused by an unavailable server or
+a protocol error.
+
+
+import com.caucho.hessian.client.HessianProxyFactory;
+
+...
+
+URL url = new URL("http://localhost:8080/ejb/hello");
+HelloHome hello = (HelloHome) factory.create(HelloHome.class, url);
+
+System.out.println("hello: " + hello.hello());
+
+
+Serialization
+
+Since the Hessian protocol serializes Java objects to XML, the
+HessianSerializerOutput and HessianSerializerInput
+can be used for serialization.
+
+Serialization
+
+OutputStream os = new FileOutputStream("test.xml");
+HessianOutput out = new HessianSerializerOutput(os);
+
+out.writeObject(obj);
+os.close();
+
+
+Deserialization
+
+InputStream is = new FileInputStream("test.xml");
+HessianInput in = new HessianSerializerInput(in);
+
+Object obj = in.readObject();
+
+is.close();
+
+
+MicroHessianInput and MicroHessianOutput
+
+These two classes only require classes from Java MicroEdition. So they
+can be extracted separately into a hessian-micro.jar. Because of this
+restriction and their small size, these two classes
+are ideal for limited size devices like mobile phones and PDAs.
+
+
+
\ No newline at end of file
diff --git a/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/AbstractDeserializer.java b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/AbstractDeserializer.java
new file mode 100644
index 0000000000..fd34993915
--- /dev/null
+++ b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/AbstractDeserializer.java
@@ -0,0 +1,167 @@
+/*
+ * Copyright (c) 2001-2004 Caucho Technology, Inc. All rights reserved.
+ *
+ * The Apache Software License, Version 1.1
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. 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.
+ *
+ * 3. The end-user documentation included with the redistribution, if
+ * any, must include the following acknowlegement:
+ * "This product includes software developed by the
+ * Caucho Technology (http://www.caucho.com/)."
+ * Alternately, this acknowlegement may appear in the software itself,
+ * if and wherever such third-party acknowlegements normally appear.
+ *
+ * 4. The names "Burlap", "Resin", and "Caucho" must not be used to
+ * endorse or promote products derived from this software without prior
+ * written permission. For written permission, please contact
+ * info@caucho.com.
+ *
+ * 5. Products derived from this software may not be called "Resin"
+ * nor may "Resin" appear in their names without prior written
+ * permission of Caucho Technology.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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 CAUCHO TECHNOLOGY OR ITS 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.
+ *
+ * @author Scott Ferguson
+ */
+
+package com.caucho.hessian4.io;
+
+import java.io.IOException;
+
+/**
+ * Deserializing an object.
+ */
+public class AbstractDeserializer implements Deserializer {
+ public static final NullDeserializer NULL = new NullDeserializer();
+
+ public Class getType()
+ {
+ return Object.class;
+ }
+
+ public boolean isReadResolve()
+ {
+ return false;
+ }
+
+ public Object readObject(AbstractHessianInput in)
+ throws IOException
+ {
+ Object obj = in.readObject();
+
+ String className = getClass().getName();
+
+ if (obj != null)
+ throw error(className + ": unexpected object " + obj.getClass().getName() + " (" + obj + ")");
+ else
+ throw error(className + ": unexpected null value");
+ }
+
+ public Object readList(AbstractHessianInput in, int length)
+ throws IOException
+ {
+ throw new UnsupportedOperationException(String.valueOf(this));
+ }
+
+ public Object readLengthList(AbstractHessianInput in, int length)
+ throws IOException
+ {
+ throw new UnsupportedOperationException(String.valueOf(this));
+ }
+
+ public Object readMap(AbstractHessianInput in)
+ throws IOException
+ {
+ Object obj = in.readObject();
+
+ String className = getClass().getName();
+
+ if (obj != null)
+ throw error(className + ": unexpected object " + obj.getClass().getName() + " (" + obj + ")");
+ else
+ throw error(className + ": unexpected null value");
+ }
+
+ /**
+ * Creates the field array for a class. The default
+ * implementation returns a String[] array.
+ *
+ * @param len number of items in the array
+ * @return the new empty array
+ */
+ public Object []createFields(int len)
+ {
+ return new String[len];
+ }
+
+ /**
+ * Creates a field value class. The default
+ * implementation returns the String.
+ *
+ * @param len number of items in the array
+ * @return the new empty array
+ */
+ public Object createField(String name)
+ {
+ return name;
+ }
+
+ public Object readObject(AbstractHessianInput in,
+ String []fieldNames)
+ throws IOException
+ {
+ return readObject(in, (Object []) fieldNames);
+ }
+
+ /**
+ * Reads an object instance from the input stream
+ */
+ public Object readObject(AbstractHessianInput in,
+ Object []fields)
+ throws IOException
+ {
+ throw new UnsupportedOperationException(toString());
+ }
+
+ protected HessianProtocolException error(String msg)
+ {
+ return new HessianProtocolException(msg);
+ }
+
+ protected String codeName(int ch)
+ {
+ if (ch < 0)
+ return "end of file";
+ else
+ return "0x" + Integer.toHexString(ch & 0xff);
+ }
+
+ /**
+ * The NullDeserializer exists as a marker for the factory classes so
+ * they save a null result.
+ */
+ static final class NullDeserializer extends AbstractDeserializer {
+ }
+}
diff --git a/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/AbstractHessianInput.java b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/AbstractHessianInput.java
new file mode 100644
index 0000000000..e28f3c1eeb
--- /dev/null
+++ b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/AbstractHessianInput.java
@@ -0,0 +1,487 @@
+/*
+ * Copyright (c) 2001-2004 Caucho Technology, Inc. All rights reserved.
+ *
+ * The Apache Software License, Version 1.1
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. 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.
+ *
+ * 3. The end-user documentation included with the redistribution, if
+ * any, must include the following acknowlegement:
+ * "This product includes software developed by the
+ * Caucho Technology (http://www.caucho.com/)."
+ * Alternately, this acknowlegement may appear in the software itself,
+ * if and wherever such third-party acknowlegements normally appear.
+ *
+ * 4. The names "Burlap", "Resin", and "Caucho" must not be used to
+ * endorse or promote products derived from this software without prior
+ * written permission. For written permission, please contact
+ * info@caucho.com.
+ *
+ * 5. Products derived from this software may not be called "Resin"
+ * nor may "Resin" appear in their names without prior written
+ * permission of Caucho Technology.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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 CAUCHO TECHNOLOGY OR ITS 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.
+ *
+ * @author Scott Ferguson
+ */
+
+package com.caucho.hessian4.io;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.Reader;
+
+/**
+ * Abstract base class for Hessian requests. Hessian users should only
+ * need to use the methods in this class.
+ *
+ *
+ * AbstractHessianInput in = ...; // get input
+ * String value;
+ *
+ * in.startReply(); // read reply header
+ * value = in.readString(); // read string value
+ * in.completeReply(); // read reply footer
+ *
+ */
+abstract public class AbstractHessianInput {
+ private HessianRemoteResolver resolver;
+ private byte []_buffer;
+
+ /**
+ * Initialize the Hessian stream with the underlying input stream.
+ */
+ public void init(InputStream is)
+ {
+ }
+
+ /**
+ * Returns the call's method
+ */
+ abstract public String getMethod();
+
+ /**
+ * Sets the resolver used to lookup remote objects.
+ */
+ public void setRemoteResolver(HessianRemoteResolver resolver)
+ {
+ this.resolver = resolver;
+ }
+
+ /**
+ * Sets the resolver used to lookup remote objects.
+ */
+ public HessianRemoteResolver getRemoteResolver()
+ {
+ return resolver;
+ }
+
+ /**
+ * Sets the serializer factory.
+ */
+ public void setSerializerFactory(SerializerFactory ser)
+ {
+ }
+
+ /**
+ * Reads the call
+ *
+ *
+ * c major minor
+ *
+ */
+ abstract public int readCall()
+ throws IOException;
+
+ /**
+ * For backward compatibility with HessianSkeleton
+ */
+ public void skipOptionalCall()
+ throws IOException
+ {
+ }
+
+ /**
+ * Reads a header, returning null if there are no headers.
+ *
+ *
+ * H b16 b8 value
+ *
+ */
+ abstract public String readHeader()
+ throws IOException;
+
+ /**
+ * Starts reading the call
+ *
+ * A successful completion will have a single value:
+ *
+ *
+ * m b16 b8 method
+ *
+ */
+ abstract public String readMethod()
+ throws IOException;
+
+ /**
+ * Reads the number of method arguments
+ *
+ * @return -1 for a variable length (hessian 1.0)
+ */
+ public int readMethodArgLength()
+ throws IOException
+ {
+ return -1;
+ }
+
+ /**
+ * Starts reading the call, including the headers.
+ *
+ * The call expects the following protocol data
+ *
+ *
+ * c major minor
+ * m b16 b8 method
+ *
+ */
+ abstract public void startCall()
+ throws IOException;
+
+ /**
+ * Completes reading the call
+ *
+ * The call expects the following protocol data
+ *
+ *
+ * Z
+ *
+ */
+ abstract public void completeCall()
+ throws IOException;
+
+ /**
+ * Reads a reply as an object.
+ * If the reply has a fault, throws the exception.
+ */
+ abstract public Object readReply(Class expectedClass)
+ throws Throwable;
+
+ /**
+ * Starts reading the reply
+ *
+ * A successful completion will have a single value:
+ *
+ *
+ * r
+ * v
+ *
+ */
+ abstract public void startReply()
+ throws Throwable;
+
+ /**
+ * Starts reading the body of the reply, i.e. after the 'r' has been
+ * parsed.
+ */
+ public void startReplyBody()
+ throws Throwable
+ {
+ }
+
+ /**
+ * Completes reading the call
+ *
+ * A successful completion will have a single value:
+ *
+ *
+ * z
+ *
+ */
+ abstract public void completeReply()
+ throws IOException;
+
+ /**
+ * Reads a boolean
+ *
+ *
+ * T
+ * F
+ *
+ */
+ abstract public boolean readBoolean()
+ throws IOException;
+
+ /**
+ * Reads a null
+ *
+ *
+ * N
+ *
+ */
+ abstract public void readNull()
+ throws IOException;
+
+ /**
+ * Reads an integer
+ *
+ *
+ * I b32 b24 b16 b8
+ *
+ */
+ abstract public int readInt()
+ throws IOException;
+
+ /**
+ * Reads a long
+ *
+ *
+ * L b64 b56 b48 b40 b32 b24 b16 b8
+ *
+ */
+ abstract public long readLong()
+ throws IOException;
+
+ /**
+ * Reads a double.
+ *
+ *
+ * D b64 b56 b48 b40 b32 b24 b16 b8
+ *
+ */
+ abstract public double readDouble()
+ throws IOException;
+
+ /**
+ * Reads a date.
+ *
+ *
+ * T b64 b56 b48 b40 b32 b24 b16 b8
+ *
+ */
+ abstract public long readUTCDate()
+ throws IOException;
+
+ /**
+ * Reads a string encoded in UTF-8
+ *
+ *
+ * s b16 b8 non-final string chunk
+ * S b16 b8 final string chunk
+ *
+ */
+ abstract public String readString()
+ throws IOException;
+
+ /**
+ * Reads an XML node encoded in UTF-8
+ *
+ *
+ * x b16 b8 non-final xml chunk
+ * X b16 b8 final xml chunk
+ *
+ */
+ public org.w3c.dom.Node readNode()
+ throws IOException
+ {
+ throw new UnsupportedOperationException(getClass().getSimpleName());
+ }
+
+ /**
+ * Starts reading a string. All the characters must be read before
+ * calling the next method. The actual characters will be read with
+ * the reader's read() or read(char [], int, int).
+ *
+ *
+ * s b16 b8 non-final string chunk
+ * S b16 b8 final string chunk
+ *
+ */
+ abstract public Reader getReader()
+ throws IOException;
+
+ /**
+ * Starts reading a byte array using an input stream. All the bytes
+ * must be read before calling the following method.
+ *
+ *
+ * b b16 b8 non-final binary chunk
+ * B b16 b8 final binary chunk
+ *
+ */
+ abstract public InputStream readInputStream()
+ throws IOException;
+
+ /**
+ * Reads data to an output stream.
+ *
+ *
+ * b b16 b8 non-final binary chunk
+ * B b16 b8 final binary chunk
+ *
+ */
+ public boolean readToOutputStream(OutputStream os)
+ throws IOException
+ {
+ InputStream is = readInputStream();
+
+ if (is == null)
+ return false;
+
+ if (_buffer == null)
+ _buffer = new byte[256];
+
+ try {
+ int len;
+
+ while ((len = is.read(_buffer, 0, _buffer.length)) > 0) {
+ os.write(_buffer, 0, len);
+ }
+
+ return true;
+ } finally {
+ is.close();
+ }
+ }
+
+
+
+ /**
+ * Reads a byte array.
+ *
+ *
+ * b b16 b8 non-final binary chunk
+ * B b16 b8 final binary chunk
+ *
+ */
+ abstract public byte []readBytes()
+ throws IOException;
+
+ /**
+ * Reads an arbitrary object from the input stream.
+ *
+ * @param expectedClass the expected class if the protocol doesn't supply it.
+ */
+ abstract public Object readObject(Class expectedClass)
+ throws IOException;
+
+ /**
+ * Reads an arbitrary object from the input stream.
+ */
+ abstract public Object readObject()
+ throws IOException;
+
+ /**
+ * Reads a remote object reference to the stream. The type is the
+ * type of the remote interface.
+ *
+ *
+ * 'r' 't' b16 b8 type url
+ *
+ * R b32 b24 b16 b8
+ *
+ */
+ abstract public Object readRef()
+ throws IOException;
+
+ /**
+ * Adds an object reference.
+ */
+ abstract public int addRef(Object obj)
+ throws IOException;
+
+ /**
+ * Sets an object reference.
+ */
+ abstract public void setRef(int i, Object obj)
+ throws IOException;
+
+ /**
+ * Resets the references for streaming.
+ */
+ public void resetReferences()
+ {
+ }
+
+ /**
+ * Reads the start of a list
+ */
+ abstract public int readListStart()
+ throws IOException;
+
+ /**
+ * Reads the length of a list.
+ */
+ abstract public int readLength()
+ throws IOException;
+
+ /**
+ * Reads the start of a map
+ */
+ abstract public int readMapStart()
+ throws IOException;
+
+ /**
+ * Reads an object type.
+ */
+ abstract public String readType()
+ throws IOException;
+
+ /**
+ * Returns true if the data has ended.
+ */
+ abstract public boolean isEnd()
+ throws IOException;
+
+ /**
+ * Read the end byte
+ */
+ abstract public void readEnd()
+ throws IOException;
+
+ /**
+ * Read the end byte
+ */
+ abstract public void readMapEnd()
+ throws IOException;
+
+ /**
+ * Read the end byte
+ */
+ abstract public void readListEnd()
+ throws IOException;
+
+ public void close()
+ throws IOException
+ {
+ }
+}
diff --git a/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/AbstractHessianOutput.java b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/AbstractHessianOutput.java
new file mode 100644
index 0000000000..0e1bcc3ffe
--- /dev/null
+++ b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/AbstractHessianOutput.java
@@ -0,0 +1,582 @@
+/*
+ * Copyright (c) 2001-2008 Caucho Technology, Inc. All rights reserved.
+ *
+ * The Apache Software License, Version 1.1
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. 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.
+ *
+ * 3. The end-user documentation included with the redistribution, if
+ * any, must include the following acknowlegement:
+ * "This product includes software developed by the
+ * Caucho Technology (http://www.caucho.com/)."
+ * Alternately, this acknowlegement may appear in the software itself,
+ * if and wherever such third-party acknowlegements normally appear.
+ *
+ * 4. The names "Hessian", "Resin", and "Caucho" must not be used to
+ * endorse or promote products derived from this software without prior
+ * written permission. For written permission, please contact
+ * info@caucho.com.
+ *
+ * 5. Products derived from this software may not be called "Resin"
+ * nor may "Resin" appear in their names without prior written
+ * permission of Caucho Technology.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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 CAUCHO TECHNOLOGY OR ITS 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.
+ *
+ * @author Scott Ferguson
+ */
+
+package com.caucho.hessian4.io;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+/**
+ * Abstract output stream for Hessian requests.
+ *
+ *
+ * OutputStream os = ...; // from http connection
+ * AbstractOutput out = new HessianSerializerOutput(os);
+ * String value;
+ *
+ * out.startCall("hello"); // start hello call
+ * out.writeString("arg1"); // write a string argument
+ * out.completeCall(); // complete the call
+ *
+ */
+abstract public class AbstractHessianOutput {
+ // serializer factory
+ private SerializerFactory _defaultSerializerFactory;
+
+ // serializer factory
+ protected SerializerFactory _serializerFactory;
+
+ private byte []_byteBuffer;
+
+ /**
+ * Sets the serializer factory.
+ */
+ public void setSerializerFactory(SerializerFactory factory)
+ {
+ _serializerFactory = factory;
+ }
+
+ /**
+ * Gets the serializer factory.
+ */
+ public SerializerFactory getSerializerFactory()
+ {
+ // the default serializer factory cannot be modified by external
+ // callers
+ if (_serializerFactory == _defaultSerializerFactory) {
+ _serializerFactory = new SerializerFactory();
+ }
+
+ return _serializerFactory;
+ }
+
+ /**
+ * Gets the serializer factory.
+ */
+ protected final SerializerFactory findSerializerFactory()
+ {
+ SerializerFactory factory = _serializerFactory;
+
+ if (factory == null) {
+ factory = SerializerFactory.createDefault();
+ _defaultSerializerFactory = factory;
+ _serializerFactory = factory;
+ }
+
+ return factory;
+ }
+
+ /**
+ * Initialize the output with a new underlying stream.
+ */
+ public void init(OutputStream os)
+ {
+ }
+
+ /**
+ * Writes a complete method call.
+ */
+ public void call(String method, Object []args)
+ throws IOException
+ {
+ int length = args != null ? args.length : 0;
+
+ startCall(method, length);
+
+ for (int i = 0; i < length; i++)
+ writeObject(args[i]);
+
+ completeCall();
+ }
+
+ /**
+ * Starts the method call:
+ *
+ *
+ * C
+ *
+ * C string int
+ *
+ * string
+ *
+ *
+ * T
+ * F
+ *
+ * I b32 b24 b16 b8
+ *
+ * L b64 b56 b48 b40 b32 b24 b16 b8
+ *
+ * D b64 b56 b48 b40 b32 b24 b16 b8
+ *
+ * T b64 b56 b48 b40 b32 b24 b16 b8
+ *
+ * N
+ *
+ * S b16 b8 string-value
+ *
+ * N
+ *
+ * S b16 b8 string-value
+ *
+ * N
+ *
+ * B b16 b18 bytes
+ *
+ * N
+ *
+ * B b16 b18 bytes
+ *
+ * N
+ *
+ * b b16 b18 bytes
+ *
+ * b b16 b18 bytes
+ *
+ * Q int
+ *
+ * R b32 b24 b16 b8
+ * writeListBegin followed by the list contents and then
+ * call writeListEnd.
+ *
+ *
+ * V
+ * x13 java.util.ArrayList # type
+ * x93 # length=3
+ * x91 # 1
+ * x92 # 2
+ * x93 # 3
+ * </list>
+ * writeMapBegin followed by the map contents and then
+ * call writeMapEnd.
+ *
+ *
+ * M type ( )* Z
+ * writeObjectBegin followed by the map contents and then
+ * call writeObjectEnd.
+ *
+ *
+ * C type int *
+ * C int *
+ * valueMap = new HashMap(8);
+
+ while (! in.isEnd()) {
+ String key = in.readString();
+ Object value = in.readObject();
+
+ valueMap.put(key, value);
+ }
+
+ in.readMapEnd();
+
+ return Proxy.newProxyInstance(_annType.getClassLoader(),
+ new Class[] { _annType },
+ new AnnotationInvocationHandler(_annType, valueMap));
+
+ } catch (IOException e) {
+ throw e;
+ } catch (Exception e) {
+ throw new IOExceptionWrapper(e);
+ }
+ }
+
+ public Object readObject(AbstractHessianInput in,
+ Object []fields)
+ throws IOException
+ {
+ String []fieldNames = (String []) fields;
+
+ try {
+ int ref = in.addRef(null);
+
+ HashMap valueMap = new HashMap(8);
+
+ for (int i = 0; i < fieldNames.length; i++) {
+ String name = fieldNames[i];
+
+ valueMap.put(name, in.readObject());
+ }
+
+ return Proxy.newProxyInstance(_annType.getClassLoader(),
+ new Class[] { _annType },
+ new AnnotationInvocationHandler(_annType, valueMap));
+
+ } catch (IOException e) {
+ throw e;
+ } catch (Exception e) {
+ throw new HessianException(_annType.getName() + ":" + e, e);
+ }
+ }
+}
diff --git a/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/AnnotationInvocationHandler.java b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/AnnotationInvocationHandler.java
new file mode 100644
index 0000000000..93e5979262
--- /dev/null
+++ b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/AnnotationInvocationHandler.java
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) 2001-2008 Caucho Technology, Inc. All rights reserved.
+ *
+ * The Apache Software License, Version 1.1
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. 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.
+ *
+ * 3. The end-user documentation included with the redistribution, if
+ * any, must include the following acknowlegement:
+ * "This product includes software developed by the
+ * Caucho Technology (http://www.caucho.com/)."
+ * Alternately, this acknowlegement may appear in the software itself,
+ * if and wherever such third-party acknowlegements normally appear.
+ *
+ * 4. The names "Burlap", "Resin", and "Caucho" must not be used to
+ * endorse or promote products derived from this software without prior
+ * written permission. For written permission, please contact
+ * info@caucho.com.
+ *
+ * 5. Products derived from this software may not be called "Resin"
+ * nor may "Resin" appear in their names without prior written
+ * permission of Caucho Technology.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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 CAUCHO TECHNOLOGY OR ITS 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.
+ *
+ * @author Scott Ferguson
+ */
+
+package com.caucho.hessian4.io;
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Proxy for a java annotation for known object types.
+ */
+public class AnnotationInvocationHandler implements InvocationHandler {
+ private Class _annType;
+ private HashMap _valueMap;
+
+ public AnnotationInvocationHandler(Class annType,
+ HashMap valueMap)
+ {
+ _annType = annType;
+ _valueMap = valueMap;
+ }
+
+ public Object invoke(Object proxy, Method method, Object []args)
+ throws Throwable
+ {
+ String name = method.getName();
+
+ if (args != null && args.length != 0)
+ return null;
+
+ if (name.equals("annotationType"))
+ return _annType;
+ else if (name.equals("toString"))
+ return toString();
+
+ return _valueMap.get(method.getName());
+ }
+
+ public String toString()
+ {
+ StringBuilder sb = new StringBuilder();
+
+ sb.append("@");
+ sb.append(_annType.getName());
+ sb.append("[");
+
+ boolean isFirst = true;
+ for (Map.Entry entry : _valueMap.entrySet()) {
+ if (! isFirst)
+ sb.append(", ");
+ isFirst = false;
+
+ sb.append(entry.getKey());
+ sb.append("=");
+
+ if (entry.getValue() instanceof String)
+ sb.append('"').append(entry.getValue()).append('"');
+ else
+ sb.append(entry.getValue());
+ }
+ sb.append("]");
+
+ return sb.toString();
+ }
+}
diff --git a/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/AnnotationSerializer.java b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/AnnotationSerializer.java
new file mode 100644
index 0000000000..63d5db589e
--- /dev/null
+++ b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/AnnotationSerializer.java
@@ -0,0 +1,392 @@
+/*
+ * Copyright (c) 2001-2008 Caucho Technology, Inc. All rights reserved.
+ *
+ * The Apache Software License, Version 1.1
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. 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.
+ *
+ * 3. The end-user documentation included with the redistribution, if
+ * any, must include the following acknowlegement:
+ * "This product includes software developed by the
+ * Caucho Technology (http://www.caucho.com/)."
+ * Alternately, this acknowlegement may appear in the software itself,
+ * if and wherever such third-party acknowlegements normally appear.
+ *
+ * 4. The names "Burlap", "Resin", and "Caucho" must not be used to
+ * endorse or promote products derived from this software without prior
+ * written permission. For written permission, please contact
+ * info@caucho.com.
+ *
+ * 5. Products derived from this software may not be called "Resin"
+ * nor may "Resin" appear in their names without prior written
+ * permission of Caucho Technology.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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 CAUCHO TECHNOLOGY OR ITS 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.
+ *
+ * @author Scott Ferguson
+ */
+
+package com.caucho.hessian4.io;
+
+import java.io.IOException;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import com.caucho.hessian4.HessianException;
+
+/**
+ * Serializing a Java annotation
+ */
+public class AnnotationSerializer extends AbstractSerializer
+{
+ private static final Logger log
+ = Logger.getLogger(AnnotationSerializer.class.getName());
+
+ private static Object []NULL_ARGS = new Object[0];
+
+ private Class _annType;
+ private Method []_methods;
+ private MethodSerializer []_methodSerializers;
+
+ public AnnotationSerializer(Class annType)
+ {
+ if (! Annotation.class.isAssignableFrom(annType)) {
+ throw new IllegalStateException(annType.getName() + " is invalid because it is not a java.lang.annotation.Annotation");
+ }
+ }
+
+ public void writeObject(Object obj, AbstractHessianOutput out)
+ throws IOException
+ {
+ if (out.addRef(obj)) {
+ return;
+ }
+
+ init(((Annotation) obj).annotationType());
+
+ int ref = out.writeObjectBegin(_annType.getName());
+
+ if (ref < -1) {
+ writeObject10(obj, out);
+ }
+ else {
+ if (ref == -1) {
+ writeDefinition20(out);
+ out.writeObjectBegin(_annType.getName());
+ }
+
+ writeInstance(obj, out);
+ }
+ }
+
+ protected void writeObject10(Object obj, AbstractHessianOutput out)
+ throws IOException
+ {
+ for (int i = 0; i < _methods.length; i++) {
+ Method method = _methods[i];
+
+ out.writeString(method.getName());
+
+ _methodSerializers[i].serialize(out, obj, method);
+ }
+
+ out.writeMapEnd();
+ }
+
+ private void writeDefinition20(AbstractHessianOutput out)
+ throws IOException
+ {
+ out.writeClassFieldLength(_methods.length);
+
+ for (int i = 0; i < _methods.length; i++) {
+ Method method = _methods[i];
+
+ out.writeString(method.getName());
+ }
+ }
+
+ public void writeInstance(Object obj, AbstractHessianOutput out)
+ throws IOException
+ {
+ for (int i = 0; i < _methods.length; i++) {
+ Method method = _methods[i];
+
+ _methodSerializers[i].serialize(out, obj, method);
+ }
+ }
+
+
+ private void init(Class cl)
+ {
+ synchronized (this) {
+ if (_annType != null)
+ return;
+
+ _annType = cl;
+
+ ArrayList methods = new ArrayList();
+
+ for (Method method : _annType.getDeclaredMethods()) {
+ if (method.getName().equals("hashCode")
+ || method.getName().equals("toString")
+ || method.getName().equals("annotationType")) {
+ continue;
+ }
+
+ if (method.getParameterTypes().length != 0)
+ continue;
+
+ methods.add(method);
+
+ method.setAccessible(true);
+ }
+
+ if (_annType == null)
+ throw new IllegalStateException(cl.getName() + " is invalid because it does not have a valid annotationType()");
+
+ _methods = new Method[methods.size()];
+ methods.toArray(_methods);
+
+ _methodSerializers = new MethodSerializer[_methods.length];
+
+ for (int i = 0; i < _methods.length; i++) {
+ _methodSerializers[i] = getMethodSerializer(_methods[i].getReturnType());
+ }
+ }
+ }
+
+ private Class getAnnotationType(Class cl)
+ {
+ if (cl == null)
+ return null;
+
+ if (Annotation.class.equals(cl.getSuperclass()))
+ return cl;
+
+ Class ifaces[] = cl.getInterfaces();
+
+ if (ifaces != null) {
+ for (Class iface : ifaces) {
+ if (iface.equals(Annotation.class))
+ return cl;
+
+ Class annType = getAnnotationType(iface);
+
+ if (annType != null)
+ return annType;
+ }
+ }
+
+ return getAnnotationType(cl.getSuperclass());
+ }
+
+ private static MethodSerializer getMethodSerializer(Class type)
+ {
+ if (int.class.equals(type)
+ || byte.class.equals(type)
+ || short.class.equals(type)
+ || int.class.equals(type)) {
+ return IntMethodSerializer.SER;
+ }
+ else if (long.class.equals(type)) {
+ return LongMethodSerializer.SER;
+ }
+ else if (double.class.equals(type) ||
+ float.class.equals(type)) {
+ return DoubleMethodSerializer.SER;
+ }
+ else if (boolean.class.equals(type)) {
+ return BooleanMethodSerializer.SER;
+ }
+ else if (String.class.equals(type)) {
+ return StringMethodSerializer.SER;
+ }
+ else if (java.util.Date.class.equals(type)
+ || java.sql.Date.class.equals(type)
+ || java.sql.Timestamp.class.equals(type)
+ || java.sql.Time.class.equals(type)) {
+ return DateMethodSerializer.SER;
+ }
+ else
+ return MethodSerializer.SER;
+ }
+
+ static HessianException error(Method method, Throwable cause)
+ {
+ String msg = (method.getDeclaringClass().getSimpleName()
+ + "." + method.getName() + "(): " + cause);
+
+ throw new HessianMethodSerializationException(msg, cause);
+ }
+
+ static class MethodSerializer {
+ static final MethodSerializer SER = new MethodSerializer();
+
+ void serialize(AbstractHessianOutput out, Object obj, Method method)
+ throws IOException
+ {
+ Object value = null;
+
+ try {
+ value = method.invoke(obj);
+ } catch (InvocationTargetException e) {
+ throw error(method, e.getCause());
+ } catch (IllegalAccessException e) {
+ log.log(Level.FINE, e.toString(), e);
+ }
+
+ try {
+ out.writeObject(value);
+ } catch (Exception e) {
+ throw error(method, e);
+ }
+ }
+ }
+
+ static class BooleanMethodSerializer extends MethodSerializer {
+ static final MethodSerializer SER = new BooleanMethodSerializer();
+
+ void serialize(AbstractHessianOutput out, Object obj, Method method)
+ throws IOException
+ {
+ boolean value = false;
+
+ try {
+ value = (Boolean) method.invoke(obj);
+ } catch (InvocationTargetException e) {
+ throw error(method, e.getCause());
+ } catch (IllegalAccessException e) {
+ log.log(Level.FINE, e.toString(), e);
+ }
+
+ out.writeBoolean(value);
+ }
+ }
+
+ static class IntMethodSerializer extends MethodSerializer {
+ static final MethodSerializer SER = new IntMethodSerializer();
+
+ void serialize(AbstractHessianOutput out, Object obj, Method method)
+ throws IOException
+ {
+ int value = 0;
+
+ try {
+ value = (Integer) method.invoke(obj);
+ } catch (InvocationTargetException e) {
+ throw error(method, e.getCause());
+ } catch (IllegalAccessException e) {
+ log.log(Level.FINE, e.toString(), e);
+ }
+
+ out.writeInt(value);
+ }
+ }
+
+ static class LongMethodSerializer extends MethodSerializer {
+ static final MethodSerializer SER = new LongMethodSerializer();
+
+ void serialize(AbstractHessianOutput out, Object obj, Method method)
+ throws IOException
+ {
+ long value = 0;
+
+ try {
+ value = (Long) method.invoke(obj);
+ } catch (InvocationTargetException e) {
+ throw error(method, e.getCause());
+ } catch (IllegalAccessException e) {
+ log.log(Level.FINE, e.toString(), e);
+ }
+
+ out.writeLong(value);
+ }
+ }
+
+ static class DoubleMethodSerializer extends MethodSerializer {
+ static final MethodSerializer SER = new DoubleMethodSerializer();
+
+ void serialize(AbstractHessianOutput out, Object obj, Method method)
+ throws IOException
+ {
+ double value = 0;
+
+ try {
+ value = (Double) method.invoke(obj);
+ } catch (InvocationTargetException e) {
+ throw error(method, e.getCause());
+ } catch (IllegalAccessException e) {
+ log.log(Level.FINE, e.toString(), e);
+ }
+
+ out.writeDouble(value);
+ }
+ }
+
+ static class StringMethodSerializer extends MethodSerializer {
+ static final MethodSerializer SER = new StringMethodSerializer();
+
+ void serialize(AbstractHessianOutput out, Object obj, Method method)
+ throws IOException
+ {
+ String value = null;
+
+ try {
+ value = (String) method.invoke(obj);
+ } catch (InvocationTargetException e) {
+ throw error(method, e.getCause());
+ } catch (IllegalAccessException e) {
+ log.log(Level.FINE, e.toString(), e);
+ }
+
+ out.writeString(value);
+ }
+ }
+
+ static class DateMethodSerializer extends MethodSerializer {
+ static final MethodSerializer SER = new DateMethodSerializer();
+
+ void serialize(AbstractHessianOutput out, Object obj, Method method)
+ throws IOException
+ {
+ java.util.Date value = null;
+
+ try {
+ value = (java.util.Date) method.invoke(obj);
+ } catch (InvocationTargetException e) {
+ throw error(method, e.getCause());
+ } catch (IllegalAccessException e) {
+ log.log(Level.FINE, e.toString(), e);
+ }
+
+ if (value == null)
+ out.writeNull();
+ else
+ out.writeUTCDate(value.getTime());
+ }
+ }
+}
diff --git a/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/ArrayDeserializer.java b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/ArrayDeserializer.java
new file mode 100644
index 0000000000..70f3791063
--- /dev/null
+++ b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/ArrayDeserializer.java
@@ -0,0 +1,164 @@
+/*
+ * Copyright (c) 2001-2004 Caucho Technology, Inc. All rights reserved.
+ *
+ * The Apache Software License, Version 1.1
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. 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.
+ *
+ * 3. The end-user documentation included with the redistribution, if
+ * any, must include the following acknowlegement:
+ * "This product includes software developed by the
+ * Caucho Technology (http://www.caucho.com/)."
+ * Alternately, this acknowlegement may appear in the software itself,
+ * if and wherever such third-party acknowlegements normally appear.
+ *
+ * 4. The names "Hessian", "Resin", and "Caucho" must not be used to
+ * endorse or promote products derived from this software without prior
+ * written permission. For written permission, please contact
+ * info@caucho.com.
+ *
+ * 5. Products derived from this software may not be called "Resin"
+ * nor may "Resin" appear in their names without prior written
+ * permission of Caucho Technology.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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 CAUCHO TECHNOLOGY OR ITS 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.
+ *
+ * @author Scott Ferguson
+ */
+
+package com.caucho.hessian4.io;
+
+import java.io.IOException;
+import java.lang.reflect.Array;
+import java.util.ArrayList;
+
+/**
+ * Deserializing a Java array
+ */
+public class ArrayDeserializer extends AbstractListDeserializer {
+ private Class _componentType;
+ private Class _type;
+
+ public ArrayDeserializer(Class componentType)
+ {
+ _componentType = componentType;
+
+ if (_componentType != null) {
+ try {
+ _type = Array.newInstance(_componentType, 0).getClass();
+ } catch (Exception e) {
+ }
+ }
+
+ if (_type == null)
+ _type = Object[].class;
+ }
+
+ public Class getType()
+ {
+ return _type;
+ }
+
+ /**
+ * Reads the array.
+ */
+ public Object readList(AbstractHessianInput in, int length)
+ throws IOException
+ {
+ if (length >= 0) {
+ Object []data = createArray(length);
+
+ in.addRef(data);
+
+ if (_componentType != null) {
+ for (int i = 0; i < data.length; i++)
+ data[i] = in.readObject(_componentType);
+ }
+ else {
+ for (int i = 0; i < data.length; i++)
+ data[i] = in.readObject();
+ }
+
+ in.readListEnd();
+
+ return data;
+ }
+ else {
+ ArrayList list = new ArrayList();
+
+ in.addRef(list);
+
+ if (_componentType != null) {
+ while (! in.isEnd())
+ list.add(in.readObject(_componentType));
+ }
+ else {
+ while (! in.isEnd())
+ list.add(in.readObject());
+ }
+
+ in.readListEnd();
+
+ Object []data = createArray(list.size());
+ for (int i = 0; i < data.length; i++)
+ data[i] = list.get(i);
+
+ return data;
+ }
+ }
+
+ /**
+ * Reads the array.
+ */
+ public Object readLengthList(AbstractHessianInput in, int length)
+ throws IOException
+ {
+ Object []data = createArray(length);
+
+ in.addRef(data);
+
+ if (_componentType != null) {
+ for (int i = 0; i < data.length; i++)
+ data[i] = in.readObject(_componentType);
+ }
+ else {
+ for (int i = 0; i < data.length; i++)
+ data[i] = in.readObject();
+ }
+
+ return data;
+ }
+
+ protected Object []createArray(int length)
+ {
+ if (_componentType != null)
+ return (Object []) Array.newInstance(_componentType, length);
+ else
+ return new Object[length];
+ }
+
+ public String toString()
+ {
+ return "ArrayDeserializer[" + _componentType + "]";
+ }
+}
diff --git a/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/ArraySerializer.java b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/ArraySerializer.java
new file mode 100644
index 0000000000..8afc611eb0
--- /dev/null
+++ b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/ArraySerializer.java
@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) 2001-2004 Caucho Technology, Inc. All rights reserved.
+ *
+ * The Apache Software License, Version 1.1
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. 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.
+ *
+ * 3. The end-user documentation included with the redistribution, if
+ * any, must include the following acknowlegement:
+ * "This product includes software developed by the
+ * Caucho Technology (http://www.caucho.com/)."
+ * Alternately, this acknowlegement may appear in the software itself,
+ * if and wherever such third-party acknowlegements normally appear.
+ *
+ * 4. The names "Hessian", "Resin", and "Caucho" must not be used to
+ * endorse or promote products derived from this software without prior
+ * written permission. For written permission, please contact
+ * info@caucho.com.
+ *
+ * 5. Products derived from this software may not be called "Resin"
+ * nor may "Resin" appear in their names without prior written
+ * permission of Caucho Technology.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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 CAUCHO TECHNOLOGY OR ITS 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.
+ *
+ * @author Scott Ferguson
+ */
+
+package com.caucho.hessian4.io;
+
+import java.io.IOException;
+
+/**
+ * Serializing a Java array.
+ */
+public class ArraySerializer extends AbstractSerializer {
+ public void writeObject(Object obj, AbstractHessianOutput out)
+ throws IOException
+ {
+ if (out.addRef(obj))
+ return;
+
+ Object []array = (Object []) obj;
+
+ boolean hasEnd = out.writeListBegin(array.length,
+ getArrayType(obj.getClass()));
+
+ for (int i = 0; i < array.length; i++)
+ out.writeObject(array[i]);
+
+ if (hasEnd)
+ out.writeListEnd();
+ }
+
+ /**
+ * Returns the <type> name for a <list>.
+ */
+ private String getArrayType(Class cl)
+ {
+ if (cl.isArray())
+ return '[' + getArrayType(cl.getComponentType());
+
+ String name = cl.getName();
+
+ if (name.equals("java.lang.String"))
+ return "string";
+ else if (name.equals("java.lang.Object"))
+ return "object";
+ else if (name.equals("java.util.Date"))
+ return "date";
+ else
+ return name;
+ }
+}
diff --git a/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/BasicDeserializer.java b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/BasicDeserializer.java
new file mode 100644
index 0000000000..9faef4a343
--- /dev/null
+++ b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/BasicDeserializer.java
@@ -0,0 +1,608 @@
+/*
+ * Copyright (c) 2001-2008 Caucho Technology, Inc. All rights reserved.
+ *
+ * The Apache Software License, Version 1.1
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. 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.
+ *
+ * 3. The end-user documentation included with the redistribution, if
+ * any, must include the following acknowlegement:
+ * "This product includes software developed by the
+ * Caucho Technology (http://www.caucho.com/)."
+ * Alternately, this acknowlegement may appear in the software itself,
+ * if and wherever such third-party acknowlegements normally appear.
+ *
+ * 4. The names "Burlap", "Resin", and "Caucho" must not be used to
+ * endorse or promote products derived from this software without prior
+ * written permission. For written permission, please contact
+ * info@caucho.com.
+ *
+ * 5. Products derived from this software may not be called "Resin"
+ * nor may "Resin" appear in their names without prior written
+ * permission of Caucho Technology.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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 CAUCHO TECHNOLOGY OR ITS 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.
+ *
+ * @author Scott Ferguson
+ */
+
+package com.caucho.hessian4.io;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Date;
+
+/**
+ * Serializing an object for known object types.
+ */
+public class BasicDeserializer extends AbstractDeserializer {
+ public static final int NULL = BasicSerializer.NULL;
+ public static final int BOOLEAN = BasicSerializer.BOOLEAN;
+ public static final int BYTE = BasicSerializer.BYTE;
+ public static final int SHORT = BasicSerializer.SHORT;
+ public static final int INTEGER = BasicSerializer.INTEGER;
+ public static final int LONG = BasicSerializer.LONG;
+ public static final int FLOAT = BasicSerializer.FLOAT;
+ public static final int DOUBLE = BasicSerializer.DOUBLE;
+ public static final int CHARACTER = BasicSerializer.CHARACTER;
+ public static final int CHARACTER_OBJECT = BasicSerializer.CHARACTER_OBJECT;
+ public static final int STRING = BasicSerializer.STRING;
+ public static final int DATE = BasicSerializer.DATE;
+ public static final int NUMBER = BasicSerializer.NUMBER;
+ public static final int OBJECT = BasicSerializer.OBJECT;
+
+ public static final int BOOLEAN_ARRAY = BasicSerializer.BOOLEAN_ARRAY;
+ public static final int BYTE_ARRAY = BasicSerializer.BYTE_ARRAY;
+ public static final int SHORT_ARRAY = BasicSerializer.SHORT_ARRAY;
+ public static final int INTEGER_ARRAY = BasicSerializer.INTEGER_ARRAY;
+ public static final int LONG_ARRAY = BasicSerializer.LONG_ARRAY;
+ public static final int FLOAT_ARRAY = BasicSerializer.FLOAT_ARRAY;
+ public static final int DOUBLE_ARRAY = BasicSerializer.DOUBLE_ARRAY;
+ public static final int CHARACTER_ARRAY = BasicSerializer.CHARACTER_ARRAY;
+ public static final int STRING_ARRAY = BasicSerializer.STRING_ARRAY;
+ public static final int OBJECT_ARRAY = BasicSerializer.OBJECT_ARRAY;
+
+ private int _code;
+
+ public BasicDeserializer(int code)
+ {
+ _code = code;
+ }
+
+ public Class getType()
+ {
+ switch (_code) {
+ case NULL:
+ return void.class;
+ case BOOLEAN:
+ return Boolean.class;
+ case BYTE:
+ return Byte.class;
+ case SHORT:
+ return Short.class;
+ case INTEGER:
+ return Integer.class;
+ case LONG:
+ return Long.class;
+ case FLOAT:
+ return Float.class;
+ case DOUBLE:
+ return Double.class;
+ case CHARACTER:
+ return Character.class;
+ case CHARACTER_OBJECT:
+ return Character.class;
+ case STRING:
+ return String.class;
+ case DATE:
+ return Date.class;
+ case NUMBER:
+ return Number.class;
+ case OBJECT:
+ return Object.class;
+
+ case BOOLEAN_ARRAY:
+ return boolean[].class;
+ case BYTE_ARRAY:
+ return byte[].class;
+ case SHORT_ARRAY:
+ return short[].class;
+ case INTEGER_ARRAY:
+ return int[].class;
+ case LONG_ARRAY:
+ return long[].class;
+ case FLOAT_ARRAY:
+ return float[].class;
+ case DOUBLE_ARRAY:
+ return double[].class;
+ case CHARACTER_ARRAY:
+ return char[].class;
+ case STRING_ARRAY:
+ return String[].class;
+ case OBJECT_ARRAY:
+ return Object[].class;
+ default:
+ throw new UnsupportedOperationException();
+ }
+ }
+
+ public Object readObject(AbstractHessianInput in)
+ throws IOException
+ {
+ switch (_code) {
+ case NULL:
+ // hessian/3490
+ in.readObject();
+
+ return null;
+
+ case BOOLEAN:
+ return Boolean.valueOf(in.readBoolean());
+
+ case BYTE:
+ return Byte.valueOf((byte) in.readInt());
+
+ case SHORT:
+ return Short.valueOf((short) in.readInt());
+
+ case INTEGER:
+ return Integer.valueOf(in.readInt());
+
+ case LONG:
+ return Long.valueOf(in.readLong());
+
+ case FLOAT:
+ return Float.valueOf((float) in.readDouble());
+
+ case DOUBLE:
+ return Double.valueOf(in.readDouble());
+
+ case STRING:
+ return in.readString();
+
+ case OBJECT:
+ return in.readObject();
+
+ case CHARACTER:
+ {
+ String s = in.readString();
+ if (s == null || s.equals(""))
+ return Character.valueOf((char) 0);
+ else
+ return Character.valueOf(s.charAt(0));
+ }
+
+ case CHARACTER_OBJECT:
+ {
+ String s = in.readString();
+ if (s == null || s.equals(""))
+ return null;
+ else
+ return Character.valueOf(s.charAt(0));
+ }
+
+ case DATE:
+ return new Date(in.readUTCDate());
+
+ case NUMBER:
+ return in.readObject();
+
+ case BYTE_ARRAY:
+ return in.readBytes();
+
+ case CHARACTER_ARRAY:
+ {
+ String s = in.readString();
+
+ if (s == null)
+ return null;
+ else {
+ int len = s.length();
+ char []chars = new char[len];
+ s.getChars(0, len, chars, 0);
+ return chars;
+ }
+ }
+
+ case BOOLEAN_ARRAY:
+ case SHORT_ARRAY:
+ case INTEGER_ARRAY:
+ case LONG_ARRAY:
+ case FLOAT_ARRAY:
+ case DOUBLE_ARRAY:
+ case STRING_ARRAY:
+ {
+ int code = in.readListStart();
+
+ switch (code) {
+ case 'N':
+ return null;
+
+ case 0x10: case 0x11: case 0x12: case 0x13:
+ case 0x14: case 0x15: case 0x16: case 0x17:
+ case 0x18: case 0x19: case 0x1a: case 0x1b:
+ case 0x1c: case 0x1d: case 0x1e: case 0x1f:
+ int length = code - 0x10;
+ in.readInt();
+
+ return readLengthList(in, length);
+
+ default:
+ String type = in.readType();
+ length = in.readLength();
+
+ return readList(in, length);
+ }
+ }
+
+ default:
+ throw new UnsupportedOperationException();
+ }
+ }
+
+ public Object readList(AbstractHessianInput in, int length)
+ throws IOException
+ {
+ switch (_code) {
+ case BOOLEAN_ARRAY: {
+ if (length >= 0) {
+ boolean []data = new boolean[length];
+
+ in.addRef(data);
+
+ for (int i = 0; i < data.length; i++)
+ data[i] = in.readBoolean();
+
+ in.readEnd();
+
+ return data;
+ }
+ else {
+ ArrayList list = new ArrayList();
+
+ while (! in.isEnd())
+ list.add(Boolean.valueOf(in.readBoolean()));
+
+ in.readEnd();
+
+ boolean []data = new boolean[list.size()];
+
+ in.addRef(data);
+
+ for (int i = 0; i < data.length; i++)
+ data[i] = ((Boolean) list.get(i)).booleanValue();
+
+ return data;
+ }
+ }
+
+ case SHORT_ARRAY: {
+ if (length >= 0) {
+ short []data = new short[length];
+
+ in.addRef(data);
+
+ for (int i = 0; i < data.length; i++)
+ data[i] = (short) in.readInt();
+
+ in.readEnd();
+
+ return data;
+ }
+ else {
+ ArrayList list = new ArrayList();
+
+ while (! in.isEnd())
+ list.add(Short.valueOf((short) in.readInt()));
+
+ in.readEnd();
+
+ short []data = new short[list.size()];
+ for (int i = 0; i < data.length; i++)
+ data[i] = ((Short) list.get(i)).shortValue();
+
+ in.addRef(data);
+
+ return data;
+ }
+ }
+
+ case INTEGER_ARRAY: {
+ if (length >= 0) {
+ int []data = new int[length];
+
+ in.addRef(data);
+
+ for (int i = 0; i < data.length; i++)
+ data[i] = in.readInt();
+
+ in.readEnd();
+
+ return data;
+ }
+ else {
+ ArrayList list = new ArrayList();
+
+ while (! in.isEnd())
+ list.add(Integer.valueOf(in.readInt()));
+
+
+ in.readEnd();
+
+ int []data = new int[list.size()];
+ for (int i = 0; i < data.length; i++)
+ data[i] = ((Integer) list.get(i)).intValue();
+
+ in.addRef(data);
+
+ return data;
+ }
+ }
+
+ case LONG_ARRAY: {
+ if (length >= 0) {
+ long []data = new long[length];
+
+ in.addRef(data);
+
+ for (int i = 0; i < data.length; i++)
+ data[i] = in.readLong();
+
+ in.readEnd();
+
+ return data;
+ }
+ else {
+ ArrayList list = new ArrayList();
+
+ while (! in.isEnd())
+ list.add(Long.valueOf(in.readLong()));
+
+ in.readEnd();
+
+ long []data = new long[list.size()];
+ for (int i = 0; i < data.length; i++)
+ data[i] = ((Long) list.get(i)).longValue();
+
+ in.addRef(data);
+
+ return data;
+ }
+ }
+
+ case FLOAT_ARRAY: {
+ if (length >= 0) {
+ float []data = new float[length];
+ in.addRef(data);
+
+ for (int i = 0; i < data.length; i++)
+ data[i] = (float) in.readDouble();
+
+ in.readEnd();
+
+ return data;
+ }
+ else {
+ ArrayList list = new ArrayList();
+
+ while (! in.isEnd())
+ list.add(new Float(in.readDouble()));
+
+ in.readEnd();
+
+ float []data = new float[list.size()];
+ for (int i = 0; i < data.length; i++)
+ data[i] = ((Float) list.get(i)).floatValue();
+
+ in.addRef(data);
+
+ return data;
+ }
+ }
+
+ case DOUBLE_ARRAY: {
+ if (length >= 0) {
+ double []data = new double[length];
+ in.addRef(data);
+
+ for (int i = 0; i < data.length; i++)
+ data[i] = in.readDouble();
+
+ in.readEnd();
+
+ return data;
+ }
+ else {
+ ArrayList list = new ArrayList();
+
+ while (! in.isEnd())
+ list.add(new Double(in.readDouble()));
+
+ in.readEnd();
+
+ double []data = new double[list.size()];
+ in.addRef(data);
+ for (int i = 0; i < data.length; i++)
+ data[i] = ((Double) list.get(i)).doubleValue();
+
+ return data;
+ }
+ }
+
+ case STRING_ARRAY: {
+ if (length >= 0) {
+ String []data = new String[length];
+ in.addRef(data);
+
+ for (int i = 0; i < data.length; i++)
+ data[i] = in.readString();
+
+ in.readEnd();
+
+ return data;
+ }
+ else {
+ ArrayList list = new ArrayList();
+
+ while (! in.isEnd())
+ list.add(in.readString());
+
+ in.readEnd();
+
+ String []data = new String[list.size()];
+ in.addRef(data);
+ for (int i = 0; i < data.length; i++)
+ data[i] = (String) list.get(i);
+
+ return data;
+ }
+ }
+
+ case OBJECT_ARRAY: {
+ if (length >= 0) {
+ Object []data = new Object[length];
+ in.addRef(data);
+
+ for (int i = 0; i < data.length; i++)
+ data[i] = in.readObject();
+
+ in.readEnd();
+
+ return data;
+ }
+ else {
+ ArrayList list = new ArrayList();
+
+ in.addRef(list); // XXX: potential issues here
+
+ while (! in.isEnd())
+ list.add(in.readObject());
+
+ in.readEnd();
+
+ Object []data = new Object[list.size()];
+ for (int i = 0; i < data.length; i++)
+ data[i] = (Object) list.get(i);
+
+ return data;
+ }
+ }
+
+ default:
+ throw new UnsupportedOperationException(String.valueOf(this));
+ }
+ }
+
+ public Object readLengthList(AbstractHessianInput in, int length)
+ throws IOException
+ {
+ switch (_code) {
+ case BOOLEAN_ARRAY: {
+ boolean []data = new boolean[length];
+
+ in.addRef(data);
+
+ for (int i = 0; i < data.length; i++)
+ data[i] = in.readBoolean();
+
+ return data;
+ }
+
+ case SHORT_ARRAY: {
+ short []data = new short[length];
+
+ in.addRef(data);
+
+ for (int i = 0; i < data.length; i++)
+ data[i] = (short) in.readInt();
+
+ return data;
+ }
+
+ case INTEGER_ARRAY: {
+ int []data = new int[length];
+
+ in.addRef(data);
+
+ for (int i = 0; i < data.length; i++)
+ data[i] = in.readInt();
+
+ return data;
+ }
+
+ case LONG_ARRAY: {
+ long []data = new long[length];
+
+ in.addRef(data);
+
+ for (int i = 0; i < data.length; i++)
+ data[i] = in.readLong();
+
+ return data;
+ }
+
+ case FLOAT_ARRAY: {
+ float []data = new float[length];
+ in.addRef(data);
+
+ for (int i = 0; i < data.length; i++)
+ data[i] = (float) in.readDouble();
+
+ return data;
+ }
+
+ case DOUBLE_ARRAY: {
+ double []data = new double[length];
+ in.addRef(data);
+
+ for (int i = 0; i < data.length; i++)
+ data[i] = in.readDouble();
+
+ return data;
+ }
+
+ case STRING_ARRAY: {
+ String []data = new String[length];
+ in.addRef(data);
+
+ for (int i = 0; i < data.length; i++)
+ data[i] = in.readString();
+
+ return data;
+ }
+
+ case OBJECT_ARRAY: {
+ Object []data = new Object[length];
+ in.addRef(data);
+
+ for (int i = 0; i < data.length; i++)
+ data[i] = in.readObject();
+
+ return data;
+ }
+
+ default:
+ throw new UnsupportedOperationException(String.valueOf(this));
+ }
+ }
+}
diff --git a/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/BasicSerializer.java b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/BasicSerializer.java
new file mode 100644
index 0000000000..c9ed7febfc
--- /dev/null
+++ b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/BasicSerializer.java
@@ -0,0 +1,330 @@
+/*
+ * Copyright (c) 2001-2004 Caucho Technology, Inc. All rights reserved.
+ *
+ * The Apache Software License, Version 1.1
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. 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.
+ *
+ * 3. The end-user documentation included with the redistribution, if
+ * any, must include the following acknowlegement:
+ * "This product includes software developed by the
+ * Caucho Technology (http://www.caucho.com/)."
+ * Alternately, this acknowlegement may appear in the software itself,
+ * if and wherever such third-party acknowlegements normally appear.
+ *
+ * 4. The names "Burlap", "Resin", and "Caucho" must not be used to
+ * endorse or promote products derived from this software without prior
+ * written permission. For written permission, please contact
+ * info@caucho.com.
+ *
+ * 5. Products derived from this software may not be called "Resin"
+ * nor may "Resin" appear in their names without prior written
+ * permission of Caucho Technology.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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 CAUCHO TECHNOLOGY OR ITS 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.
+ *
+ * @author Scott Ferguson
+ */
+
+package com.caucho.hessian4.io;
+
+import java.io.IOException;
+import java.util.Date;
+
+/**
+ * Serializing an object for known object types.
+ */
+public class BasicSerializer extends AbstractSerializer
+ implements ObjectSerializer
+{
+ public static final int NULL = 0;
+ public static final int BOOLEAN = NULL + 1;
+ public static final int BYTE = BOOLEAN + 1;
+ public static final int SHORT = BYTE + 1;
+ public static final int INTEGER = SHORT + 1;
+ public static final int LONG = INTEGER + 1;
+ public static final int FLOAT = LONG + 1;
+ public static final int DOUBLE = FLOAT + 1;
+ public static final int CHARACTER = DOUBLE + 1;
+ public static final int CHARACTER_OBJECT = CHARACTER + 1;
+ public static final int STRING = CHARACTER_OBJECT + 1;
+ public static final int DATE = STRING + 1;
+ public static final int NUMBER = DATE + 1;
+ public static final int OBJECT = NUMBER + 1;
+
+ public static final int BOOLEAN_ARRAY = OBJECT + 1;
+ public static final int BYTE_ARRAY = BOOLEAN_ARRAY + 1;
+ public static final int SHORT_ARRAY = BYTE_ARRAY + 1;
+ public static final int INTEGER_ARRAY = SHORT_ARRAY + 1;
+ public static final int LONG_ARRAY = INTEGER_ARRAY + 1;
+ public static final int FLOAT_ARRAY = LONG_ARRAY + 1;
+ public static final int DOUBLE_ARRAY = FLOAT_ARRAY + 1;
+ public static final int CHARACTER_ARRAY = DOUBLE_ARRAY + 1;
+ public static final int STRING_ARRAY = CHARACTER_ARRAY + 1;
+ public static final int OBJECT_ARRAY = STRING_ARRAY + 1;
+
+ public static final int BYTE_HANDLE = OBJECT_ARRAY + 1;
+ public static final int SHORT_HANDLE = BYTE_HANDLE + 1;
+ public static final int FLOAT_HANDLE = SHORT_HANDLE + 1;
+
+ private static final BasicSerializer BYTE_HANDLE_SERIALIZER
+ = new BasicSerializer(BYTE_HANDLE);
+
+ private static final BasicSerializer SHORT_HANDLE_SERIALIZER
+ = new BasicSerializer(SHORT_HANDLE);
+
+ private static final BasicSerializer FLOAT_HANDLE_SERIALIZER
+ = new BasicSerializer(FLOAT_HANDLE);
+
+ private int _code;
+
+ public BasicSerializer(int code)
+ {
+ _code = code;
+ }
+
+ public Serializer getObjectSerializer()
+ {
+ switch (_code) {
+ case BYTE:
+ return BYTE_HANDLE_SERIALIZER;
+ case SHORT:
+ return SHORT_HANDLE_SERIALIZER;
+ case FLOAT:
+ return FLOAT_HANDLE_SERIALIZER;
+ default:
+ return this;
+ }
+ }
+
+ public void writeObject(Object obj, AbstractHessianOutput out)
+ throws IOException
+ {
+ switch (_code) {
+ case BOOLEAN:
+ out.writeBoolean(((Boolean) obj).booleanValue());
+ break;
+
+ case BYTE:
+ case SHORT:
+ case INTEGER:
+ out.writeInt(((Number) obj).intValue());
+ break;
+
+ case LONG:
+ out.writeLong(((Number) obj).longValue());
+ break;
+
+ case FLOAT:
+ case DOUBLE:
+ out.writeDouble(((Number) obj).doubleValue());
+ break;
+
+ case CHARACTER:
+ case CHARACTER_OBJECT:
+ out.writeString(String.valueOf(obj));
+ break;
+
+ case STRING:
+ out.writeString((String) obj);
+ break;
+
+ case DATE:
+ out.writeUTCDate(((Date) obj).getTime());
+ break;
+
+ case BOOLEAN_ARRAY:
+ {
+ if (out.addRef(obj))
+ return;
+
+ boolean []data = (boolean []) obj;
+ boolean hasEnd = out.writeListBegin(data.length, "[boolean");
+ for (int i = 0; i < data.length; i++)
+ out.writeBoolean(data[i]);
+
+ if (hasEnd)
+ out.writeListEnd();
+
+ break;
+ }
+
+ case BYTE_ARRAY:
+ {
+ byte []data = (byte []) obj;
+ out.writeBytes(data, 0, data.length);
+ break;
+ }
+
+ case SHORT_ARRAY:
+ {
+ if (out.addRef(obj))
+ return;
+
+ short []data = (short []) obj;
+ boolean hasEnd = out.writeListBegin(data.length, "[short");
+
+ for (int i = 0; i < data.length; i++)
+ out.writeInt(data[i]);
+
+ if (hasEnd)
+ out.writeListEnd();
+ break;
+ }
+
+ case INTEGER_ARRAY:
+ {
+ if (out.addRef(obj))
+ return;
+
+ int []data = (int []) obj;
+
+ boolean hasEnd = out.writeListBegin(data.length, "[int");
+
+ for (int i = 0; i < data.length; i++)
+ out.writeInt(data[i]);
+
+ if (hasEnd)
+ out.writeListEnd();
+
+ break;
+ }
+
+ case LONG_ARRAY:
+ {
+ if (out.addRef(obj))
+ return;
+
+ long []data = (long []) obj;
+
+ boolean hasEnd = out.writeListBegin(data.length, "[long");
+
+ for (int i = 0; i < data.length; i++)
+ out.writeLong(data[i]);
+
+ if (hasEnd)
+ out.writeListEnd();
+ break;
+ }
+
+ case FLOAT_ARRAY:
+ {
+ if (out.addRef(obj))
+ return;
+
+ float []data = (float []) obj;
+
+ boolean hasEnd = out.writeListBegin(data.length, "[float");
+
+ for (int i = 0; i < data.length; i++)
+ out.writeDouble(data[i]);
+
+ if (hasEnd)
+ out.writeListEnd();
+ break;
+ }
+
+ case DOUBLE_ARRAY:
+ {
+ if (out.addRef(obj))
+ return;
+
+ double []data = (double []) obj;
+ boolean hasEnd = out.writeListBegin(data.length, "[double");
+
+ for (int i = 0; i < data.length; i++)
+ out.writeDouble(data[i]);
+
+ if (hasEnd)
+ out.writeListEnd();
+ break;
+ }
+
+ case STRING_ARRAY:
+ {
+ if (out.addRef(obj))
+ return;
+
+ String []data = (String []) obj;
+
+ boolean hasEnd = out.writeListBegin(data.length, "[string");
+
+ for (int i = 0; i < data.length; i++) {
+ out.writeString(data[i]);
+ }
+
+ if (hasEnd)
+ out.writeListEnd();
+ break;
+ }
+
+ case CHARACTER_ARRAY:
+ {
+ char []data = (char []) obj;
+ out.writeString(data, 0, data.length);
+ break;
+ }
+
+ case OBJECT_ARRAY:
+ {
+ if (out.addRef(obj))
+ return;
+
+ Object []data = (Object []) obj;
+
+ boolean hasEnd = out.writeListBegin(data.length, "[object");
+
+ for (int i = 0; i < data.length; i++) {
+ out.writeObject(data[i]);
+ }
+
+ if (hasEnd)
+ out.writeListEnd();
+ break;
+ }
+
+ case NULL:
+ out.writeNull();
+ break;
+
+ case OBJECT:
+ ObjectHandleSerializer.SER.writeObject(obj, out);
+ break;
+
+ case BYTE_HANDLE:
+ out.writeObject(new ByteHandle((Byte) obj));
+ break;
+
+ case SHORT_HANDLE:
+ out.writeObject(new ShortHandle((Short) obj));
+ break;
+
+ case FLOAT_HANDLE:
+ out.writeObject(new FloatHandle((Float) obj));
+ break;
+
+ default:
+ throw new RuntimeException(_code + " unknown code for " + obj.getClass());
+ }
+ }
+}
diff --git a/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/BeanDeserializer.java b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/BeanDeserializer.java
new file mode 100644
index 0000000000..bccc1e5dea
--- /dev/null
+++ b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/BeanDeserializer.java
@@ -0,0 +1,295 @@
+/*
+ * Copyright (c) 2001-2008 Caucho Technology, Inc. All rights reserved.
+ *
+ * The Apache Software License, Version 1.1
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. 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.
+ *
+ * 3. The end-user documentation included with the redistribution, if
+ * any, must include the following acknowlegement:
+ * "This product includes software developed by the
+ * Caucho Technology (http://www.caucho.com/)."
+ * Alternately, this acknowlegement may appear in the software itself,
+ * if and wherever such third-party acknowlegements normally appear.
+ *
+ * 4. The names "Burlap", "Resin", and "Caucho" must not be used to
+ * endorse or promote products derived from this software without prior
+ * written permission. For written permission, please contact
+ * info@caucho.com.
+ *
+ * 5. Products derived from this software may not be called "Resin"
+ * nor may "Resin" appear in their names without prior written
+ * permission of Caucho Technology.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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 CAUCHO TECHNOLOGY OR ITS 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.
+ *
+ * @author Scott Ferguson
+ */
+
+package com.caucho.hessian4.io;
+
+import java.io.IOException;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.HashMap;
+
+/**
+ * Serializing an object for known object types.
+ */
+public class BeanDeserializer extends AbstractMapDeserializer {
+ private Class _type;
+ private HashMap _methodMap;
+ private Method _readResolve;
+ private Constructor _constructor;
+ private Object []_constructorArgs;
+
+ public BeanDeserializer(Class cl)
+ {
+ _type = cl;
+ _methodMap = getMethodMap(cl);
+
+ _readResolve = getReadResolve(cl);
+
+ Constructor []constructors = cl.getConstructors();
+ int bestLength = Integer.MAX_VALUE;
+
+ for (int i = 0; i < constructors.length; i++) {
+ if (constructors[i].getParameterTypes().length < bestLength) {
+ _constructor = constructors[i];
+ bestLength = _constructor.getParameterTypes().length;
+ }
+ }
+
+ if (_constructor != null) {
+ _constructor.setAccessible(true);
+ Class []params = _constructor.getParameterTypes();
+ _constructorArgs = new Object[params.length];
+ for (int i = 0; i < params.length; i++) {
+ _constructorArgs[i] = getParamArg(params[i]);
+ }
+ }
+ }
+
+ public Class getType()
+ {
+ return _type;
+ }
+
+ public Object readMap(AbstractHessianInput in)
+ throws IOException
+ {
+ try {
+ Object obj = instantiate();
+
+ return readMap(in, obj);
+ } catch (IOException e) {
+ throw e;
+ } catch (Exception e) {
+ throw new IOExceptionWrapper(e);
+ }
+ }
+
+ public Object readMap(AbstractHessianInput in, Object obj)
+ throws IOException
+ {
+ try {
+ int ref = in.addRef(obj);
+
+ while (! in.isEnd()) {
+ Object key = in.readObject();
+
+ Method method = (Method) _methodMap.get(key);
+
+ if (method != null) {
+ Object value = in.readObject(method.getParameterTypes()[0]);
+
+ method.invoke(obj, new Object[] {value });
+ }
+ else {
+ Object value = in.readObject();
+ }
+ }
+
+ in.readMapEnd();
+
+ Object resolve = resolve(obj);
+
+ if (obj != resolve)
+ in.setRef(ref, resolve);
+
+ return resolve;
+ } catch (IOException e) {
+ throw e;
+ } catch (Exception e) {
+ throw new IOExceptionWrapper(e);
+ }
+ }
+
+ private Object resolve(Object obj)
+ {
+ // if there's a readResolve method, call it
+ try {
+ if (_readResolve != null)
+ return _readResolve.invoke(obj, new Object[0]);
+ } catch (Exception e) {
+ }
+
+ return obj;
+ }
+
+ protected Object instantiate()
+ throws Exception
+ {
+ return _constructor.newInstance(_constructorArgs);
+ }
+
+ /**
+ * Returns the readResolve method
+ */
+ protected Method getReadResolve(Class cl)
+ {
+ for (; cl != null; cl = cl.getSuperclass()) {
+ Method []methods = cl.getDeclaredMethods();
+
+ for (int i = 0; i < methods.length; i++) {
+ Method method = methods[i];
+
+ if (method.getName().equals("readResolve") &&
+ method.getParameterTypes().length == 0)
+ return method;
+ }
+ }
+
+ return null;
+ }
+
+ /**
+ * Creates a map of the classes fields.
+ */
+ protected HashMap getMethodMap(Class cl)
+ {
+ HashMap methodMap = new HashMap();
+
+ for (; cl != null; cl = cl.getSuperclass()) {
+ Method []methods = cl.getDeclaredMethods();
+
+ for (int i = 0; i < methods.length; i++) {
+ Method method = methods[i];
+
+ if (Modifier.isStatic(method.getModifiers()))
+ continue;
+
+ String name = method.getName();
+
+ if (! name.startsWith("set"))
+ continue;
+
+ Class []paramTypes = method.getParameterTypes();
+ if (paramTypes.length != 1)
+ continue;
+
+ if (! method.getReturnType().equals(void.class))
+ continue;
+
+ if (findGetter(methods, name, paramTypes[0]) == null)
+ continue;
+
+ // XXX: could parameterize the handler to only deal with public
+ try {
+ method.setAccessible(true);
+ } catch (Throwable e) {
+ e.printStackTrace();
+ }
+
+ name = name.substring(3);
+
+ int j = 0;
+ for (; j < name.length() && Character.isUpperCase(name.charAt(j)); j++) {
+ }
+
+ if (j == 1)
+ name = name.substring(0, j).toLowerCase() + name.substring(j);
+ else if (j > 1)
+ name = name.substring(0, j - 1).toLowerCase() + name.substring(j - 1);
+
+
+ methodMap.put(name, method);
+ }
+ }
+
+ return methodMap;
+ }
+
+ /**
+ * Finds any matching setter.
+ */
+ private Method findGetter(Method []methods, String setterName, Class arg)
+ {
+ String getterName = "get" + setterName.substring(3);
+
+ for (int i = 0; i < methods.length; i++) {
+ Method method = methods[i];
+
+ if (! method.getName().equals(getterName))
+ continue;
+
+ if (! method.getReturnType().equals(arg))
+ continue;
+
+ Class []params = method.getParameterTypes();
+
+ if (params.length == 0)
+ return method;
+ }
+
+ return null;
+ }
+
+ /**
+ * Creates a map of the classes fields.
+ */
+ protected static Object getParamArg(Class cl)
+ {
+ if (! cl.isPrimitive())
+ return null;
+ else if (boolean.class.equals(cl))
+ return Boolean.FALSE;
+ else if (byte.class.equals(cl))
+ return Byte.valueOf((byte) 0);
+ else if (short.class.equals(cl))
+ return Short.valueOf((short) 0);
+ else if (char.class.equals(cl))
+ return Character.valueOf((char) 0);
+ else if (int.class.equals(cl))
+ return Integer.valueOf(0);
+ else if (long.class.equals(cl))
+ return Long.valueOf(0);
+ else if (float.class.equals(cl))
+ return Double.valueOf(0);
+ else if (double.class.equals(cl))
+ return Double.valueOf(0);
+ else
+ throw new UnsupportedOperationException();
+ }
+}
diff --git a/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/BeanSerializer.java b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/BeanSerializer.java
new file mode 100644
index 0000000000..77af6aa2e3
--- /dev/null
+++ b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/BeanSerializer.java
@@ -0,0 +1,316 @@
+/*
+ * Copyright (c) 2001-2004 Caucho Technology, Inc. All rights reserved.
+ *
+ * The Apache Software License, Version 1.1
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. 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.
+ *
+ * 3. The end-user documentation included with the redistribution, if
+ * any, must include the following acknowlegement:
+ * "This product includes software developed by the
+ * Caucho Technology (http://www.caucho.com/)."
+ * Alternately, this acknowlegement may appear in the software itself,
+ * if and wherever such third-party acknowlegements normally appear.
+ *
+ * 4. The names "Burlap", "Resin", and "Caucho" must not be used to
+ * endorse or promote products derived from this software without prior
+ * written permission. For written permission, please contact
+ * info@caucho.com.
+ *
+ * 5. Products derived from this software may not be called "Resin"
+ * nor may "Resin" appear in their names without prior written
+ * permission of Caucho Technology.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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 CAUCHO TECHNOLOGY OR ITS 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.
+ *
+ * @author Scott Ferguson
+ */
+
+package com.caucho.hessian4.io;
+
+import java.io.IOException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * Serializing an object for known object types.
+ */
+public class BeanSerializer extends AbstractSerializer {
+ private static final Logger log
+ = Logger.getLogger(BeanSerializer.class.getName());
+
+ private static final Object []NULL_ARGS = new Object[0];
+ private Method []_methods;
+ private String []_names;
+
+ private Object _writeReplaceFactory;
+ private Method _writeReplace;
+
+ public BeanSerializer(Class cl, ClassLoader loader)
+ {
+ introspectWriteReplace(cl, loader);
+
+ ArrayList primitiveMethods = new ArrayList();
+ ArrayList compoundMethods = new ArrayList();
+
+ for (; cl != null; cl = cl.getSuperclass()) {
+ Method []methods = cl.getDeclaredMethods();
+
+ for (int i = 0; i < methods.length; i++) {
+ Method method = methods[i];
+
+ if (Modifier.isStatic(method.getModifiers()))
+ continue;
+
+ if (method.getParameterTypes().length != 0)
+ continue;
+
+ String name = method.getName();
+
+ if (! name.startsWith("get"))
+ continue;
+
+ Class type = method.getReturnType();
+
+ if (type.equals(void.class))
+ continue;
+
+ if (findSetter(methods, name, type) == null)
+ continue;
+
+ // XXX: could parameterize the handler to only deal with public
+ method.setAccessible(true);
+
+ if (type.isPrimitive()
+ || type.getName().startsWith("java.lang.")
+ && ! type.equals(Object.class))
+ primitiveMethods.add(method);
+ else
+ compoundMethods.add(method);
+ }
+ }
+
+ ArrayList methodList = new ArrayList();
+ methodList.addAll(primitiveMethods);
+ methodList.addAll(compoundMethods);
+
+ Collections.sort(methodList, new MethodNameCmp());
+
+ _methods = new Method[methodList.size()];
+ methodList.toArray(_methods);
+
+ _names = new String[_methods.length];
+
+ for (int i = 0; i < _methods.length; i++) {
+ String name = _methods[i].getName();
+
+ name = name.substring(3);
+
+ int j = 0;
+ for (; j < name.length() && Character.isUpperCase(name.charAt(j)); j++) {
+ }
+
+ if (j == 1)
+ name = name.substring(0, j).toLowerCase() + name.substring(j);
+ else if (j > 1)
+ name = name.substring(0, j - 1).toLowerCase() + name.substring(j - 1);
+
+ _names[i] = name;
+ }
+ }
+
+ private void introspectWriteReplace(Class cl, ClassLoader loader)
+ {
+ try {
+ String className = cl.getName() + "HessianSerializer";
+
+ Class serializerClass = Class.forName(className, false, loader);
+
+ Object serializerObject = serializerClass.newInstance();
+
+ Method writeReplace = getWriteReplace(serializerClass, cl);
+
+ if (writeReplace != null) {
+ _writeReplaceFactory = serializerObject;
+ _writeReplace = writeReplace;
+
+ return;
+ }
+ } catch (ClassNotFoundException e) {
+ } catch (Exception e) {
+ log.log(Level.FINER, e.toString(), e);
+ }
+
+ _writeReplace = getWriteReplace(cl);
+ }
+
+ /**
+ * Returns the writeReplace method
+ */
+ protected Method getWriteReplace(Class cl)
+ {
+ for (; cl != null; cl = cl.getSuperclass()) {
+ Method []methods = cl.getDeclaredMethods();
+
+ for (int i = 0; i < methods.length; i++) {
+ Method method = methods[i];
+
+ if (method.getName().equals("writeReplace") &&
+ method.getParameterTypes().length == 0)
+ return method;
+ }
+ }
+
+ return null;
+ }
+
+ /**
+ * Returns the writeReplace method
+ */
+ protected Method getWriteReplace(Class cl, Class param)
+ {
+ for (; cl != null; cl = cl.getSuperclass()) {
+ for (Method method : cl.getDeclaredMethods()) {
+ if (method.getName().equals("writeReplace")
+ && method.getParameterTypes().length == 1
+ && param.equals(method.getParameterTypes()[0]))
+ return method;
+ }
+ }
+
+ return null;
+ }
+
+ public void writeObject(Object obj, AbstractHessianOutput out)
+ throws IOException
+ {
+ if (out.addRef(obj))
+ return;
+
+ Class cl = obj.getClass();
+
+ try {
+ if (_writeReplace != null) {
+ Object repl;
+
+ if (_writeReplaceFactory != null)
+ repl = _writeReplace.invoke(_writeReplaceFactory, obj);
+ else
+ repl = _writeReplace.invoke(obj);
+
+ // out.removeRef(obj);
+
+ out.writeObject(repl);
+
+ out.replaceRef(repl, obj);
+
+ return;
+ }
+ } catch (Exception e) {
+ log.log(Level.FINER, e.toString(), e);
+ }
+
+ int ref = out.writeObjectBegin(cl.getName());
+
+ if (ref < -1) {
+ // Hessian 1.1 uses a map
+
+ for (int i = 0; i < _methods.length; i++) {
+ Method method = _methods[i];
+ Object value = null;
+
+ try {
+ value = _methods[i].invoke(obj, (Object []) null);
+ } catch (Exception e) {
+ log.log(Level.FINE, e.toString(), e);
+ }
+
+ out.writeString(_names[i]);
+
+ out.writeObject(value);
+ }
+
+ out.writeMapEnd();
+ }
+ else {
+ if (ref == -1) {
+ out.writeInt(_names.length);
+
+ for (int i = 0; i < _names.length; i++)
+ out.writeString(_names[i]);
+
+ out.writeObjectBegin(cl.getName());
+ }
+
+ for (int i = 0; i < _methods.length; i++) {
+ Method method = _methods[i];
+ Object value = null;
+
+ try {
+ value = _methods[i].invoke(obj, (Object []) null);
+ } catch (Exception e) {
+ log.log(Level.FINER, e.toString(), e);
+ }
+
+ out.writeObject(value);
+ }
+ }
+ }
+
+ /**
+ * Finds any matching setter.
+ */
+ private Method findSetter(Method []methods, String getterName, Class arg)
+ {
+ String setterName = "set" + getterName.substring(3);
+
+ for (int i = 0; i < methods.length; i++) {
+ Method method = methods[i];
+
+ if (! method.getName().equals(setterName))
+ continue;
+
+ if (! method.getReturnType().equals(void.class))
+ continue;
+
+ Class []params = method.getParameterTypes();
+
+ if (params.length == 1 && params[0].equals(arg))
+ return method;
+ }
+
+ return null;
+ }
+
+ static class MethodNameCmp implements Comparator {
+ public int compare(Method a, Method b)
+ {
+ return a.getName().compareTo(b.getName());
+ }
+ }
+}
diff --git a/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/BeanSerializerFactory.java b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/BeanSerializerFactory.java
new file mode 100644
index 0000000000..6231628a14
--- /dev/null
+++ b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/BeanSerializerFactory.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) 2001-2004 Caucho Technology, Inc. All rights reserved.
+ *
+ * The Apache Software License, Version 1.1
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. 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.
+ *
+ * 3. The end-user documentation included with the redistribution, if
+ * any, must include the following acknowlegement:
+ * "This product includes software developed by the
+ * Caucho Technology (http://www.caucho.com/)."
+ * Alternately, this acknowlegement may appear in the software itself,
+ * if and wherever such third-party acknowlegements normally appear.
+ *
+ * 4. The names "Burlap", "Resin", and "Caucho" must not be used to
+ * endorse or promote products derived from this software without prior
+ * written permission. For written permission, please contact
+ * info@caucho.com.
+ *
+ * 5. Products derived from this software may not be called "Resin"
+ * nor may "Resin" appear in their names without prior written
+ * permission of Caucho Technology.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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 CAUCHO TECHNOLOGY OR ITS 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.
+ *
+ * @author Scott Ferguson
+ */
+
+package com.caucho.hessian4.io;
+
+/**
+ * Factory for returning serialization methods.
+ */
+public class BeanSerializerFactory extends SerializerFactory {
+ /**
+ * Returns the default serializer for a class that isn't matched
+ * directly. Application can override this method to produce
+ * bean-style serialization instead of field serialization.
+ *
+ * @param cl the class of the object that needs to be serialized.
+ *
+ * @return a serializer object for the serialization.
+ */
+ protected Serializer getDefaultSerializer(Class cl)
+ {
+ return new BeanSerializer(cl, getClassLoader());
+ }
+
+ /**
+ * Returns the default deserializer for a class that isn't matched
+ * directly. Application can override this method to produce
+ * bean-style serialization instead of field serialization.
+ *
+ * @param cl the class of the object that needs to be serialized.
+ *
+ * @return a serializer object for the serialization.
+ */
+ protected Deserializer getDefaultDeserializer(Class cl)
+ {
+ return new BeanDeserializer(cl);
+ }
+}
diff --git a/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/BigDecimalDeserializer.java b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/BigDecimalDeserializer.java
new file mode 100644
index 0000000000..34f2bed301
--- /dev/null
+++ b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/BigDecimalDeserializer.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2001-2004 Caucho Technology, Inc. All rights reserved.
+ *
+ * The Apache Software License, Version 1.1
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. 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.
+ *
+ * 3. The end-user documentation included with the redistribution, if
+ * any, must include the following acknowlegement:
+ * "This product includes software developed by the
+ * Caucho Technology (http://www.caucho.com/)."
+ * Alternately, this acknowlegement may appear in the software itself,
+ * if and wherever such third-party acknowlegements normally appear.
+ *
+ * 4. The names "Hessian", "Resin", and "Caucho" must not be used to
+ * endorse or promote products derived from this software without prior
+ * written permission. For written permission, please contact
+ * info@caucho.com.
+ *
+ * 5. Products derived from this software may not be called "Resin"
+ * nor may "Resin" appear in their names without prior written
+ * permission of Caucho Technology.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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 CAUCHO TECHNOLOGY OR ITS 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.
+ *
+ * @author Scott Ferguson
+ */
+
+package com.caucho.hessian4.io;
+
+import java.math.BigDecimal;
+
+/**
+ * Deserializing a BigDecimal
+ */
+public class BigDecimalDeserializer extends AbstractStringValueDeserializer {
+ @Override
+ public Class getType()
+ {
+ return BigDecimal.class;
+ }
+
+ @Override
+ protected Object create(String value)
+ {
+ return new BigDecimal(value);
+ }
+}
diff --git a/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/ByteHandle.java b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/ByteHandle.java
new file mode 100644
index 0000000000..aa63cc7967
--- /dev/null
+++ b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/ByteHandle.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) 2001-2004 Caucho Technology, Inc. All rights reserved.
+ *
+ * The Apache Software License, Version 1.1
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. 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.
+ *
+ * 3. The end-user documentation included with the redistribution, if
+ * any, must include the following acknowlegement:
+ * "This product includes software developed by the
+ * Caucho Technology (http://www.caucho.com/)."
+ * Alternately, this acknowlegement may appear in the software itself,
+ * if and wherever such third-party acknowlegements normally appear.
+ *
+ * 4. The names "Burlap", "Resin", and "Caucho" must not be used to
+ * endorse or promote products derived from this software without prior
+ * written permission. For written permission, please contact
+ * info@caucho.com.
+ *
+ * 5. Products derived from this software may not be called "Resin"
+ * nor may "Resin" appear in their names without prior written
+ * permission of Caucho Technology.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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 CAUCHO TECHNOLOGY OR ITS 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.
+ *
+ * @author Scott Ferguson
+ */
+
+package com.caucho.hessian4.io;
+
+import java.io.Serializable;
+
+/**
+ * Handle for Java Byte objects.
+ */
+public class ByteHandle implements Serializable {
+ private byte _value;
+
+ private ByteHandle()
+ {
+ }
+
+ public ByteHandle(byte value)
+ {
+ _value = value;
+ }
+
+ public byte getValue()
+ {
+ return _value;
+ }
+
+ public Object readResolve()
+ {
+ return new Byte(_value);
+ }
+
+ public String toString()
+ {
+ return getClass().getSimpleName() + "[" + _value + "]";
+ }
+}
diff --git a/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/CalendarHandle.java b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/CalendarHandle.java
new file mode 100644
index 0000000000..37480e0926
--- /dev/null
+++ b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/CalendarHandle.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) 2001-2004 Caucho Technology, Inc. All rights reserved.
+ *
+ * The Apache Software License, Version 1.1
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. 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.
+ *
+ * 3. The end-user documentation included with the redistribution, if
+ * any, must include the following acknowlegement:
+ * "This product includes software developed by the
+ * Caucho Technology (http://www.caucho.com/)."
+ * Alternately, this acknowlegement may appear in the software itself,
+ * if and wherever such third-party acknowlegements normally appear.
+ *
+ * 4. The names "Hessian", "Resin", and "Caucho" must not be used to
+ * endorse or promote products derived from this software without prior
+ * written permission. For written permission, please contact
+ * info@caucho.com.
+ *
+ * 5. Products derived from this software may not be called "Resin"
+ * nor may "Resin" appear in their names without prior written
+ * permission of Caucho Technology.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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 CAUCHO TECHNOLOGY OR ITS 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.
+ *
+ * @author Scott Ferguson
+ */
+
+package com.caucho.hessian4.io;
+
+import java.util.Calendar;
+import java.util.Date;
+import java.util.GregorianCalendar;
+
+/**
+ * Handle for a calendar object.
+ */
+public class CalendarHandle implements java.io.Serializable, HessianHandle {
+ private Class type;
+ private Date date;
+
+ public CalendarHandle()
+ {
+ }
+
+ public CalendarHandle(Class type, long time)
+ {
+ if (! GregorianCalendar.class.equals(type))
+ this.type = type;
+
+ this.date = new Date(time);
+ }
+
+ private Object readResolve()
+ {
+ try {
+ Calendar cal;
+
+ if (this.type != null)
+ cal = (Calendar) this.type.newInstance();
+ else
+ cal = new GregorianCalendar();
+
+ cal.setTimeInMillis(this.date.getTime());
+
+ return cal;
+ } catch (RuntimeException e) {
+ throw e;
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+}
diff --git a/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/CalendarSerializer.java b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/CalendarSerializer.java
new file mode 100644
index 0000000000..37117f4fad
--- /dev/null
+++ b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/CalendarSerializer.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2001-2004 Caucho Technology, Inc. All rights reserved.
+ *
+ * The Apache Software License, Version 1.1
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. 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.
+ *
+ * 3. The end-user documentation included with the redistribution, if
+ * any, must include the following acknowlegement:
+ * "This product includes software developed by the
+ * Caucho Technology (http://www.caucho.com/)."
+ * Alternately, this acknowlegement may appear in the software itself,
+ * if and wherever such third-party acknowlegements normally appear.
+ *
+ * 4. The names "Hessian", "Resin", and "Caucho" must not be used to
+ * endorse or promote products derived from this software without prior
+ * written permission. For written permission, please contact
+ * info@caucho.com.
+ *
+ * 5. Products derived from this software may not be called "Resin"
+ * nor may "Resin" appear in their names without prior written
+ * permission of Caucho Technology.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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 CAUCHO TECHNOLOGY OR ITS 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.
+ *
+ * @author Scott Ferguson
+ */
+
+package com.caucho.hessian4.io;
+
+import java.util.Calendar;
+
+/**
+ * Serializing a calendar.
+ */
+public class CalendarSerializer extends AbstractSerializer {
+ public static final Serializer SER = new CalendarSerializer();
+
+ /**
+ * java.util.Calendar serializes to com.caucho.hessian.io.CalendarHandle
+ */
+ @Override
+ public Object writeReplace(Object obj)
+ {
+ Calendar cal = (Calendar) obj;
+
+ return new CalendarHandle(cal.getClass(), cal.getTimeInMillis());
+ }
+}
diff --git a/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/ClassDeserializer.java b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/ClassDeserializer.java
new file mode 100644
index 0000000000..743dfa0f75
--- /dev/null
+++ b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/ClassDeserializer.java
@@ -0,0 +1,162 @@
+/*
+ * Copyright (c) 2001-2004 Caucho Technology, Inc. All rights reserved.
+ *
+ * The Apache Software License, Version 1.1
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. 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.
+ *
+ * 3. The end-user documentation included with the redistribution, if
+ * any, must include the following acknowlegement:
+ * "This product includes software developed by the
+ * Caucho Technology (http://www.caucho.com/)."
+ * Alternately, this acknowlegement may appear in the software itself,
+ * if and wherever such third-party acknowlegements normally appear.
+ *
+ * 4. The names "Hessian", "Resin", and "Caucho" must not be used to
+ * endorse or promote products derived from this software without prior
+ * written permission. For written permission, please contact
+ * info@caucho.com.
+ *
+ * 5. Products derived from this software may not be called "Resin"
+ * nor may "Resin" appear in their names without prior written
+ * permission of Caucho Technology.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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 CAUCHO TECHNOLOGY OR ITS 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.
+ *
+ * @author Scott Ferguson
+ */
+
+package com.caucho.hessian4.io;
+
+import java.io.IOException;
+import java.util.HashMap;
+
+/**
+ * Deserializing a JDK 1.2 Class.
+ */
+public class ClassDeserializer extends AbstractMapDeserializer {
+ private static final HashMap _primClasses
+ = new HashMap();
+
+ private ClassLoader _loader;
+
+ public ClassDeserializer(ClassLoader loader)
+ {
+ _loader = loader;
+ }
+
+ public Class getType()
+ {
+ return Class.class;
+ }
+
+ public Object readMap(AbstractHessianInput in)
+ throws IOException
+ {
+ int ref = in.addRef(null);
+
+ String name = null;
+
+ while (! in.isEnd()) {
+ String key = in.readString();
+
+ if (key.equals("name"))
+ name = in.readString();
+ else
+ in.readObject();
+ }
+
+ in.readMapEnd();
+
+ Object value = create(name);
+
+ in.setRef(ref, value);
+
+ return value;
+ }
+
+ public Object readObject(AbstractHessianInput in, Object []fields)
+ throws IOException
+ {
+ String []fieldNames = (String []) fields;
+
+ int ref = in.addRef(null);
+
+ String name = null;
+
+ for (int i = 0; i < fieldNames.length; i++) {
+ if ("name".equals(fieldNames[i]))
+ name = in.readString();
+ else
+ in.readObject();
+ }
+
+ Object value = create(name);
+
+ in.setRef(ref, value);
+
+ return value;
+ }
+
+ Object create(String name)
+ throws IOException
+ {
+ if (name == null)
+ throw new IOException("Serialized Class expects name.");
+
+ Class cl = _primClasses.get(name);
+
+ if (cl != null)
+ return cl;
+
+ try {
+ if (_loader != null)
+ return Class.forName(name, false, _loader);
+ else
+ return Class.forName(name);
+ } catch (Exception e) {
+ throw new IOExceptionWrapper(e);
+ }
+ }
+
+ static {
+ _primClasses.put("void", void.class);
+ _primClasses.put("boolean", boolean.class);
+ _primClasses.put("java.lang.Boolean", Boolean.class);
+ _primClasses.put("byte", byte.class);
+ _primClasses.put("java.lang.Byte", Byte.class);
+ _primClasses.put("char", char.class);
+ _primClasses.put("java.lang.Character", Character.class);
+ _primClasses.put("short", short.class);
+ _primClasses.put("java.lang.Short", Short.class);
+ _primClasses.put("int", int.class);
+ _primClasses.put("java.lang.Integer", Integer.class);
+ _primClasses.put("long", long.class);
+ _primClasses.put("java.lang.Long", Long.class);
+ _primClasses.put("float", float.class);
+ _primClasses.put("java.lang.Float", Float.class);
+ _primClasses.put("double", double.class);
+ _primClasses.put("java.lang.Double", Double.class);
+ _primClasses.put("java.lang.String", String.class);
+ }
+}
diff --git a/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/ClassSerializer.java b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/ClassSerializer.java
new file mode 100644
index 0000000000..f8794c7efb
--- /dev/null
+++ b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/ClassSerializer.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) 2001-2004 Caucho Technology, Inc. All rights reserved.
+ *
+ * The Apache Software License, Version 1.1
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. 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.
+ *
+ * 3. The end-user documentation included with the redistribution, if
+ * any, must include the following acknowlegement:
+ * "This product includes software developed by the
+ * Caucho Technology (http://www.caucho.com/)."
+ * Alternately, this acknowlegement may appear in the software itself,
+ * if and wherever such third-party acknowlegements normally appear.
+ *
+ * 4. The names "Hessian", "Resin", and "Caucho" must not be used to
+ * endorse or promote products derived from this software without prior
+ * written permission. For written permission, please contact
+ * info@caucho.com.
+ *
+ * 5. Products derived from this software may not be called "Resin"
+ * nor may "Resin" appear in their names without prior written
+ * permission of Caucho Technology.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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 CAUCHO TECHNOLOGY OR ITS 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.
+ *
+ * @author Scott Ferguson
+ */
+
+package com.caucho.hessian4.io;
+
+import java.io.IOException;
+
+/**
+ * Serializing a remote object.
+ */
+public class ClassSerializer extends AbstractSerializer {
+ public void writeObject(Object obj, AbstractHessianOutput out)
+ throws IOException
+ {
+ Class cl = (Class) obj;
+
+ if (cl == null) {
+ out.writeNull();
+ }
+ else if (out.addRef(obj)) {
+ return;
+ }
+ else {
+ int ref = out.writeObjectBegin("java.lang.Class");
+
+ if (ref < -1) {
+ out.writeString("name");
+ out.writeString(cl.getName());
+ out.writeMapEnd();
+ }
+ else {
+ if (ref == -1) {
+ out.writeInt(1);
+ out.writeString("name");
+ out.writeObjectBegin("java.lang.Class");
+ }
+
+ out.writeString(cl.getName());
+ }
+ }
+ }
+}
diff --git a/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/CollectionDeserializer.java b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/CollectionDeserializer.java
new file mode 100644
index 0000000000..5fe0e531ed
--- /dev/null
+++ b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/CollectionDeserializer.java
@@ -0,0 +1,140 @@
+/*
+ * Copyright (c) 2001-2004 Caucho Technology, Inc. All rights reserved.
+ *
+ * The Apache Software License, Version 1.1
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. 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.
+ *
+ * 3. The end-user documentation included with the redistribution, if
+ * any, must include the following acknowlegement:
+ * "This product includes software developed by the
+ * Caucho Technology (http://www.caucho.com/)."
+ * Alternately, this acknowlegement may appear in the software itself,
+ * if and wherever such third-party acknowlegements normally appear.
+ *
+ * 4. The names "Hessian", "Resin", and "Caucho" must not be used to
+ * endorse or promote products derived from this software without prior
+ * written permission. For written permission, please contact
+ * info@caucho.com.
+ *
+ * 5. Products derived from this software may not be called "Resin"
+ * nor may "Resin" appear in their names without prior written
+ * permission of Caucho Technology.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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 CAUCHO TECHNOLOGY OR ITS 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.
+ *
+ * @author Scott Ferguson
+ */
+
+package com.caucho.hessian4.io;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.SortedSet;
+import java.util.TreeSet;
+
+/**
+ * Deserializing a JDK 1.2 Collection.
+ */
+public class CollectionDeserializer extends AbstractListDeserializer {
+ private Class _type;
+
+ public CollectionDeserializer(Class type)
+ {
+ _type = type;
+ }
+
+ public Class getType()
+ {
+ return _type;
+ }
+
+ public Object readList(AbstractHessianInput in, int length)
+ throws IOException
+ {
+ Collection list = createList();
+
+ in.addRef(list);
+
+ while (! in.isEnd())
+ list.add(in.readObject());
+
+ in.readEnd();
+
+ return list;
+ }
+
+ public Object readLengthList(AbstractHessianInput in, int length)
+ throws IOException
+ {
+ Collection list = createList();
+
+ in.addRef(list);
+
+ for (; length > 0; length--)
+ list.add(in.readObject());
+
+ return list;
+ }
+
+ private Collection createList()
+ throws IOException
+ {
+ Collection list = null;
+
+ if (_type == null)
+ list = new ArrayList();
+ else if (! _type.isInterface()) {
+ try {
+ list = (Collection) _type.newInstance();
+ } catch (Exception e) {
+ }
+ }
+
+ if (list != null) {
+ }
+ else if (SortedSet.class.isAssignableFrom(_type))
+ list = new TreeSet();
+ else if (Set.class.isAssignableFrom(_type))
+ list = new HashSet();
+ else if (List.class.isAssignableFrom(_type))
+ list = new ArrayList();
+ else if (Collection.class.isAssignableFrom(_type))
+ list = new ArrayList();
+ else {
+ try {
+ list = (Collection) _type.newInstance();
+ } catch (Exception e) {
+ throw new IOExceptionWrapper(e);
+ }
+ }
+
+ return list;
+ }
+}
+
+
diff --git a/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/CollectionSerializer.java b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/CollectionSerializer.java
new file mode 100644
index 0000000000..482db61ecb
--- /dev/null
+++ b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/CollectionSerializer.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) 2001-2004 Caucho Technology, Inc. All rights reserved.
+ *
+ * The Apache Software License, Version 1.1
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. 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.
+ *
+ * 3. The end-user documentation included with the redistribution, if
+ * any, must include the following acknowlegement:
+ * "This product includes software developed by the
+ * Caucho Technology (http://www.caucho.com/)."
+ * Alternately, this acknowlegement may appear in the software itself,
+ * if and wherever such third-party acknowlegements normally appear.
+ *
+ * 4. The names "Hessian", "Resin", and "Caucho" must not be used to
+ * endorse or promote products derived from this software without prior
+ * written permission. For written permission, please contact
+ * info@caucho.com.
+ *
+ * 5. Products derived from this software may not be called "Resin"
+ * nor may "Resin" appear in their names without prior written
+ * permission of Caucho Technology.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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 CAUCHO TECHNOLOGY OR ITS 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.
+ *
+ * @author Scott Ferguson
+ */
+
+package com.caucho.hessian4.io;
+
+import java.io.IOException;
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+
+/**
+ * Serializing a JDK 1.2 Collection.
+ */
+public class CollectionSerializer extends AbstractSerializer
+{
+ private boolean _sendJavaType = true;
+
+ /**
+ * Set true if the java type of the collection should be sent.
+ */
+ public void setSendJavaType(boolean sendJavaType)
+ {
+ _sendJavaType = sendJavaType;
+ }
+
+ /**
+ * Return true if the java type of the collection should be sent.
+ */
+ public boolean getSendJavaType()
+ {
+ return _sendJavaType;
+ }
+
+ public void writeObject(Object obj, AbstractHessianOutput out)
+ throws IOException
+ {
+ if (out.addRef(obj))
+ return;
+
+ Collection list = (Collection) obj;
+
+ Class cl = obj.getClass();
+ boolean hasEnd;
+
+ if (cl.equals(ArrayList.class)
+ || ! _sendJavaType
+ || ! Serializable.class.isAssignableFrom(cl))
+ hasEnd = out.writeListBegin(list.size(), null);
+ else
+ hasEnd = out.writeListBegin(list.size(), obj.getClass().getName());
+
+ Iterator iter = list.iterator();
+ while (iter.hasNext()) {
+ Object value = iter.next();
+
+ out.writeObject(value);
+ }
+
+ if (hasEnd)
+ out.writeListEnd();
+ }
+}
diff --git a/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/ContextSerializerFactory.java b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/ContextSerializerFactory.java
new file mode 100644
index 0000000000..62e2d072e3
--- /dev/null
+++ b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/ContextSerializerFactory.java
@@ -0,0 +1,480 @@
+/*
+ * Copyright (c) 2001-2008 Caucho Technology, Inc. All rights reserved.
+ *
+ * The Apache Software License, Version 1.1
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. 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.
+ *
+ * 3. The end-user documentation included with the redistribution, if
+ * any, must include the following acknowlegement:
+ * "This product includes software developed by the
+ * Caucho Technology (http://www.caucho.com/)."
+ * Alternately, this acknowlegement may appear in the software itself,
+ * if and wherever such third-party acknowlegements normally appear.
+ *
+ * 4. The names "Burlap", "Resin", and "Caucho" must not be used to
+ * endorse or promote products derived from this software without prior
+ * written permission. For written permission, please contact
+ * info@caucho.com.
+ *
+ * 5. Products derived from this software may not be called "Resin"
+ * nor may "Resin" appear in their names without prior written
+ * permission of Caucho Technology.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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 CAUCHO TECHNOLOGY OR ITS 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.
+ *
+ * @author Scott Ferguson
+ */
+
+package com.caucho.hessian4.io;
+
+import java.io.InputStream;
+import java.lang.ref.SoftReference;
+import java.net.URL;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Properties;
+import java.util.WeakHashMap;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import com.caucho.hessian4.HessianException;
+
+/**
+ * The classloader-specific Factory for returning serialization
+ */
+public class ContextSerializerFactory
+{
+ private static final Logger log
+ = Logger.getLogger(ContextSerializerFactory.class.getName());
+
+ private static Deserializer OBJECT_DESERIALIZER
+ = new BasicDeserializer(BasicDeserializer.OBJECT);
+
+ private static final WeakHashMap>
+ _contextRefMap
+ = new WeakHashMap>();
+
+ private static final ClassLoader _systemClassLoader;
+
+ private static HashMap _staticSerializerMap;
+ private static HashMap _staticDeserializerMap;
+ private static HashMap _staticClassNameMap;
+
+ private ContextSerializerFactory _parent;
+ private ClassLoader _loader;
+
+ private final HashSet _serializerFiles = new HashSet();
+ private final HashSet _deserializerFiles = new HashSet();
+
+ private final HashMap _serializerClassMap
+ = new HashMap();
+
+ private final ConcurrentHashMap _customSerializerMap
+ = new ConcurrentHashMap();
+
+ private final HashMap _serializerInterfaceMap
+ = new HashMap();
+
+ private final HashMap _deserializerClassMap
+ = new HashMap();
+
+ private final HashMap _deserializerClassNameMap
+ = new HashMap();
+
+ private final ConcurrentHashMap _customDeserializerMap
+ = new ConcurrentHashMap();
+
+ private final HashMap _deserializerInterfaceMap
+ = new HashMap();
+
+ public ContextSerializerFactory(ContextSerializerFactory parent,
+ ClassLoader loader)
+ {
+ if (loader == null)
+ loader = _systemClassLoader;
+
+ _loader = loader;
+
+ init();
+ }
+
+ public static ContextSerializerFactory create()
+ {
+ return create(Thread.currentThread().getContextClassLoader());
+ }
+
+ public static ContextSerializerFactory create(ClassLoader loader)
+ {
+ synchronized (_contextRefMap) {
+ SoftReference factoryRef
+ = _contextRefMap.get(loader);
+
+ ContextSerializerFactory factory = null;
+
+ if (factoryRef != null)
+ factory = factoryRef.get();
+
+ if (factory == null) {
+ ContextSerializerFactory parent = null;
+
+ if (loader != null)
+ parent = create(loader.getParent());
+
+ factory = new ContextSerializerFactory(parent, loader);
+ factoryRef = new SoftReference(factory);
+
+ _contextRefMap.put(loader, factoryRef);
+ }
+
+ return factory;
+ }
+ }
+
+ public ClassLoader getClassLoader()
+ {
+ return _loader;
+ }
+
+ /**
+ * Returns the serializer for a given class.
+ */
+ public Serializer getSerializer(String className)
+ {
+ Serializer serializer = _serializerClassMap.get(className);
+
+ if (serializer == AbstractSerializer.NULL)
+ return null;
+ else
+ return serializer;
+ }
+
+ /**
+ * Returns a custom serializer the class
+ *
+ * @param cl the class of the object that needs to be serialized.
+ *
+ * @return a serializer object for the serialization.
+ */
+ public Serializer getCustomSerializer(Class cl)
+ {
+ Serializer serializer = _customSerializerMap.get(cl.getName());
+
+ if (serializer == AbstractSerializer.NULL)
+ return null;
+ else if (serializer != null)
+ return serializer;
+
+ try {
+ Class serClass = Class.forName(cl.getName() + "HessianSerializer",
+ false, cl.getClassLoader());
+
+ Serializer ser = (Serializer) serClass.newInstance();
+
+ _customSerializerMap.put(cl.getName(), ser);
+
+ return ser;
+ } catch (ClassNotFoundException e) {
+ log.log(Level.ALL, e.toString(), e);
+ } catch (Exception e) {
+ throw new HessianException(e);
+ }
+
+ _customSerializerMap.put(cl.getName(), AbstractSerializer.NULL);
+
+ return null;
+ }
+
+ /**
+ * Returns the deserializer for a given class.
+ */
+ public Deserializer getDeserializer(String className)
+ {
+ Deserializer deserializer = _deserializerClassMap.get(className);
+
+ if (deserializer == AbstractDeserializer.NULL)
+ return null;
+ else
+ return deserializer;
+ }
+
+ /**
+ * Returns a custom deserializer the class
+ *
+ * @param cl the class of the object that needs to be deserialized.
+ *
+ * @return a deserializer object for the deserialization.
+ */
+ public Deserializer getCustomDeserializer(Class cl)
+ {
+ Deserializer deserializer = _customDeserializerMap.get(cl.getName());
+
+ if (deserializer == AbstractDeserializer.NULL)
+ return null;
+ else if (deserializer != null)
+ return deserializer;
+
+ try {
+ Class serClass = Class.forName(cl.getName() + "HessianDeserializer",
+ false, cl.getClassLoader());
+
+ Deserializer ser = (Deserializer) serClass.newInstance();
+
+ _customDeserializerMap.put(cl.getName(), ser);
+
+ return ser;
+ } catch (ClassNotFoundException e) {
+ log.log(Level.ALL, e.toString(), e);
+ } catch (Exception e) {
+ throw new HessianException(e);
+ }
+
+ _customDeserializerMap.put(cl.getName(), AbstractDeserializer.NULL);
+
+ return null;
+ }
+
+ /**
+ * Initialize the factory
+ */
+ private void init()
+ {
+ if (_parent != null) {
+ _serializerFiles.addAll(_parent._serializerFiles);
+ _deserializerFiles.addAll(_parent._deserializerFiles);
+
+ _serializerClassMap.putAll(_parent._serializerClassMap);
+ _deserializerClassMap.putAll(_parent._deserializerClassMap);
+ }
+
+ if (_parent == null) {
+ _serializerClassMap.putAll(_staticSerializerMap);
+ _deserializerClassMap.putAll(_staticDeserializerMap);
+ _deserializerClassNameMap.putAll(_staticClassNameMap);
+ }
+
+ HashMap classMap;
+
+ classMap = new HashMap();
+ initSerializerFiles("META-INF/hessian/serializers",
+ _serializerFiles,
+ classMap,
+ Serializer.class);
+
+ for (Map.Entry entry : classMap.entrySet()) {
+ try {
+ Serializer ser = (Serializer) entry.getValue().newInstance();
+
+ if (entry.getKey().isInterface())
+ _serializerInterfaceMap.put(entry.getKey(), ser);
+ else
+ _serializerClassMap.put(entry.getKey().getName(), ser);
+ } catch (Exception e) {
+ throw new HessianException(e);
+ }
+ }
+
+ classMap = new HashMap();
+ initSerializerFiles("META-INF/hessian/deserializers",
+ _deserializerFiles,
+ classMap,
+ Deserializer.class);
+
+ for (Map.Entry entry : classMap.entrySet()) {
+ try {
+ Deserializer ser = (Deserializer) entry.getValue().newInstance();
+
+ if (entry.getKey().isInterface())
+ _deserializerInterfaceMap.put(entry.getKey(), ser);
+ else {
+ _deserializerClassMap.put(entry.getKey().getName(), ser);
+ }
+ } catch (Exception e) {
+ throw new HessianException(e);
+ }
+ }
+ }
+
+ private void initSerializerFiles(String fileName,
+ HashSet fileList,
+ HashMap classMap,
+ Class type)
+ {
+ try {
+ Enumeration iter;
+
+ iter = getClassLoader().getResources(fileName);
+ while (iter.hasMoreElements()) {
+ URL url = (URL) iter.nextElement();
+
+ if (fileList.contains(url.toString()))
+ continue;
+
+ fileList.add(url.toString());
+
+ InputStream is = null;
+ try {
+ is = url.openStream();
+
+ Properties props = new Properties();
+ props.load(is);
+
+ for (Map.Entry entry : props.entrySet()) {
+ String apiName = (String) entry.getKey();
+ String serializerName = (String) entry.getValue();
+
+ Class apiClass = null;
+ Class serializerClass = null;
+
+ try {
+ apiClass = Class.forName(apiName, false, getClassLoader());
+ } catch (ClassNotFoundException e) {
+ log.fine(url + ": " + apiName + " is not available in this context: " + getClassLoader());
+ continue;
+ }
+
+ try {
+ serializerClass = Class.forName(serializerName, false, getClassLoader());
+ } catch (ClassNotFoundException e) {
+ log.fine(url + ": " + serializerName + " is not available in this context: " + getClassLoader());
+ continue;
+ }
+
+ if (! type.isAssignableFrom(serializerClass))
+ throw new HessianException(url + ": " + serializerClass.getName() + " is invalid because it does not implement " + type.getName());
+
+ classMap.put(apiClass, serializerClass);
+ }
+ } finally {
+ if (is != null)
+ is.close();
+ }
+ }
+ } catch (RuntimeException e) {
+ throw e;
+ } catch (Exception e) {
+ throw new HessianException(e);
+ }
+ }
+
+ private static void addBasic(Class cl, String typeName, int type)
+ {
+ _staticSerializerMap.put(cl.getName(), new BasicSerializer(type));
+
+ Deserializer deserializer = new BasicDeserializer(type);
+ _staticDeserializerMap.put(cl.getName(), deserializer);
+ _staticClassNameMap.put(typeName, deserializer);
+ }
+
+ static {
+ _staticSerializerMap = new HashMap();
+ _staticDeserializerMap = new HashMap();
+ _staticClassNameMap = new HashMap();
+
+ addBasic(void.class, "void", BasicSerializer.NULL);
+
+ addBasic(Boolean.class, "boolean", BasicSerializer.BOOLEAN);
+ addBasic(Byte.class, "byte", BasicSerializer.BYTE);
+ addBasic(Short.class, "short", BasicSerializer.SHORT);
+ addBasic(Integer.class, "int", BasicSerializer.INTEGER);
+ addBasic(Long.class, "long", BasicSerializer.LONG);
+ addBasic(Float.class, "float", BasicSerializer.FLOAT);
+ addBasic(Double.class, "double", BasicSerializer.DOUBLE);
+ addBasic(Character.class, "char", BasicSerializer.CHARACTER_OBJECT);
+ addBasic(String.class, "string", BasicSerializer.STRING);
+ addBasic(Object.class, "object", BasicSerializer.OBJECT);
+ addBasic(java.util.Date.class, "date", BasicSerializer.DATE);
+
+ addBasic(boolean.class, "boolean", BasicSerializer.BOOLEAN);
+ addBasic(byte.class, "byte", BasicSerializer.BYTE);
+ addBasic(short.class, "short", BasicSerializer.SHORT);
+ addBasic(int.class, "int", BasicSerializer.INTEGER);
+ addBasic(long.class, "long", BasicSerializer.LONG);
+ addBasic(float.class, "float", BasicSerializer.FLOAT);
+ addBasic(double.class, "double", BasicSerializer.DOUBLE);
+ addBasic(char.class, "char", BasicSerializer.CHARACTER);
+
+ addBasic(boolean[].class, "[boolean", BasicSerializer.BOOLEAN_ARRAY);
+ addBasic(byte[].class, "[byte", BasicSerializer.BYTE_ARRAY);
+ addBasic(short[].class, "[short", BasicSerializer.SHORT_ARRAY);
+ addBasic(int[].class, "[int", BasicSerializer.INTEGER_ARRAY);
+ addBasic(long[].class, "[long", BasicSerializer.LONG_ARRAY);
+ addBasic(float[].class, "[float", BasicSerializer.FLOAT_ARRAY);
+ addBasic(double[].class, "[double", BasicSerializer.DOUBLE_ARRAY);
+ addBasic(char[].class, "[char", BasicSerializer.CHARACTER_ARRAY);
+ addBasic(String[].class, "[string", BasicSerializer.STRING_ARRAY);
+ addBasic(Object[].class, "[object", BasicSerializer.OBJECT_ARRAY);
+
+ Deserializer objectDeserializer = new JavaDeserializer(Object.class);
+ _staticDeserializerMap.put("object", objectDeserializer);
+ _staticClassNameMap.put("object", objectDeserializer);
+
+ _staticSerializerMap.put(Class.class.getName(), new ClassSerializer());
+
+ _staticDeserializerMap.put(Number.class.getName(), new BasicDeserializer(BasicSerializer.NUMBER));
+
+ /*
+ for (Class cl : new Class[] { BigDecimal.class, File.class, ObjectName.class }) {
+ _staticSerializerMap.put(cl, StringValueSerializer.SER);
+ _staticDeserializerMap.put(cl, new StringValueDeserializer(cl));
+ }
+
+ _staticSerializerMap.put(ObjectName.class, StringValueSerializer.SER);
+ try {
+ _staticDeserializerMap.put(ObjectName.class,
+ new StringValueDeserializer(ObjectName.class));
+ } catch (Throwable e) {
+ }
+ */
+
+ _staticSerializerMap.put(java.sql.Date.class.getName(),
+ new SqlDateSerializer());
+ _staticSerializerMap.put(java.sql.Time.class.getName(),
+ new SqlDateSerializer());
+ _staticSerializerMap.put(java.sql.Timestamp.class.getName(),
+ new SqlDateSerializer());
+
+ _staticDeserializerMap.put(java.sql.Date.class.getName(),
+ new SqlDateDeserializer(java.sql.Date.class));
+ _staticDeserializerMap.put(java.sql.Time.class.getName(),
+ new SqlDateDeserializer(java.sql.Time.class));
+ _staticDeserializerMap.put(java.sql.Timestamp.class.getName(),
+ new SqlDateDeserializer(java.sql.Timestamp.class));
+
+ // hessian/3bb5
+ _staticDeserializerMap.put(StackTraceElement.class.getName(),
+ new StackTraceElementDeserializer());
+
+ ClassLoader systemClassLoader = null;
+ try {
+ systemClassLoader = ClassLoader.getSystemClassLoader();
+ } catch (Exception e) {
+ }
+
+ _systemClassLoader = systemClassLoader;
+ }
+}
+
diff --git a/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/Deflation.java b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/Deflation.java
new file mode 100644
index 0000000000..ccfd5e6a6f
--- /dev/null
+++ b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/Deflation.java
@@ -0,0 +1,204 @@
+/*
+ * Copyright (c) 2001-2004 Caucho Technology, Inc. All rights reserved.
+ *
+ * The Apache Software License, Version 1.1
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. 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.
+ *
+ * 3. The end-user documentation included with the redistribution, if
+ * any, must include the following acknowlegement:
+ * "This product includes software developed by the
+ * Caucho Technology (http://www.caucho.com/)."
+ * Alternately, this acknowlegement may appear in the software itself,
+ * if and wherever such third-party acknowlegements normally appear.
+ *
+ * 4. The names "Hessian", "Resin", and "Caucho" must not be used to
+ * endorse or promote products derived from this software without prior
+ * written permission. For written permission, please contact
+ * info@caucho.com.
+ *
+ * 5. Products derived from this software may not be called "Resin"
+ * nor may "Resin" appear in their names without prior written
+ * permission of Caucho Technology.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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 CAUCHO TECHNOLOGY OR ITS 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.
+ *
+ * @author Scott Ferguson
+ */
+
+package com.caucho.hessian4.io;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.zip.DeflaterOutputStream;
+import java.util.zip.InflaterInputStream;
+
+public class Deflation extends HessianEnvelope {
+ public Deflation()
+ {
+ }
+
+ public Hessian2Output wrap(Hessian2Output out)
+ throws IOException
+ {
+ OutputStream os = new DeflateOutputStream(out);
+
+ Hessian2Output filterOut = new Hessian2Output(os);
+
+ filterOut.setCloseStreamOnClose(true);
+
+ return filterOut;
+ }
+
+ public Hessian2Input unwrap(Hessian2Input in)
+ throws IOException
+ {
+ int version = in.readEnvelope();
+
+ String method = in.readMethod();
+
+ if (! method.equals(getClass().getName()))
+ throw new IOException("expected hessian Envelope method '" +
+ getClass().getName() + "' at '" + method + "'");
+
+ return unwrapHeaders(in);
+ }
+
+ public Hessian2Input unwrapHeaders(Hessian2Input in)
+ throws IOException
+ {
+ InputStream is = new DeflateInputStream(in);
+
+ Hessian2Input filter = new Hessian2Input(is);
+
+ filter.setCloseStreamOnClose(true);
+
+ return filter;
+ }
+
+ static class DeflateOutputStream extends OutputStream {
+ private Hessian2Output _out;
+ private OutputStream _bodyOut;
+ private DeflaterOutputStream _deflateOut;
+
+ DeflateOutputStream(Hessian2Output out)
+ throws IOException
+ {
+ _out = out;
+
+ _out.startEnvelope(Deflation.class.getName());
+
+ _out.writeInt(0);
+
+ _bodyOut = _out.getBytesOutputStream();
+
+ _deflateOut = new DeflaterOutputStream(_bodyOut);
+ }
+
+ public void write(int ch)
+ throws IOException
+ {
+ _deflateOut.write(ch);
+ }
+
+ public void write(byte []buffer, int offset, int length)
+ throws IOException
+ {
+ _deflateOut.write(buffer, offset, length);
+ }
+
+ public void close()
+ throws IOException
+ {
+ Hessian2Output out = _out;
+ _out = null;
+
+ if (out != null) {
+ _deflateOut.close();
+ _bodyOut.close();
+
+ out.writeInt(0);
+
+ out.completeEnvelope();
+
+ out.close();
+ }
+ }
+ }
+
+ static class DeflateInputStream extends InputStream {
+ private Hessian2Input _in;
+
+ private InputStream _bodyIn;
+ private InflaterInputStream _inflateIn;
+
+ DeflateInputStream(Hessian2Input in)
+ throws IOException
+ {
+ _in = in;
+
+ int len = in.readInt();
+
+ if (len != 0)
+ throw new IOException("expected no headers");
+
+ _bodyIn = _in.readInputStream();
+
+ _inflateIn = new InflaterInputStream(_bodyIn);
+ }
+
+ public int read()
+ throws IOException
+ {
+ return _inflateIn.read();
+ }
+
+ public int read(byte []buffer, int offset, int length)
+ throws IOException
+ {
+ return _inflateIn.read(buffer, offset, length);
+ }
+
+ public void close()
+ throws IOException
+ {
+ Hessian2Input in = _in;
+ _in = null;
+
+ if (in != null) {
+ _inflateIn.close();
+ _bodyIn.close();
+
+ int len = in.readInt();
+
+ if (len != 0)
+ throw new IOException("Unexpected footer");
+
+ in.completeEnvelope();
+
+ in.close();
+ }
+ }
+ }
+}
diff --git a/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/Deserializer.java b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/Deserializer.java
new file mode 100644
index 0000000000..06d81d6255
--- /dev/null
+++ b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/Deserializer.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) 2001-2004 Caucho Technology, Inc. All rights reserved.
+ *
+ * The Apache Software License, Version 1.1
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. 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.
+ *
+ * 3. The end-user documentation included with the redistribution, if
+ * any, must include the following acknowlegement:
+ * "This product includes software developed by the
+ * Caucho Technology (http://www.caucho.com/)."
+ * Alternately, this acknowlegement may appear in the software itself,
+ * if and wherever such third-party acknowlegements normally appear.
+ *
+ * 4. The names "Burlap", "Resin", and "Caucho" must not be used to
+ * endorse or promote products derived from this software without prior
+ * written permission. For written permission, please contact
+ * info@caucho.com.
+ *
+ * 5. Products derived from this software may not be called "Resin"
+ * nor may "Resin" appear in their names without prior written
+ * permission of Caucho Technology.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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 CAUCHO TECHNOLOGY OR ITS 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.
+ *
+ * @author Scott Ferguson
+ */
+
+package com.caucho.hessian4.io;
+
+import java.io.IOException;
+
+/**
+ * Deserializing an object. Custom deserializers should extend
+ * from AbstractDeserializer to avoid issues with signature
+ * changes.
+ */
+public interface Deserializer {
+ public Class getType();
+
+ public boolean isReadResolve();
+
+ public Object readObject(AbstractHessianInput in)
+ throws IOException;
+
+ public Object readList(AbstractHessianInput in, int length)
+ throws IOException;
+
+ public Object readLengthList(AbstractHessianInput in, int length)
+ throws IOException;
+
+ public Object readMap(AbstractHessianInput in)
+ throws IOException;
+
+ /**
+ * Creates an empty array for the deserializers field
+ * entries.
+ *
+ * @param len number of fields to be read
+ * @return empty array of the proper field type.
+ */
+ public Object []createFields(int len);
+
+ /**
+ * Returns the deserializer's field reader for the given name.
+ *
+ * @param name the field name
+ * @return the deserializer's internal field reader
+ */
+ public Object createField(String name);
+
+ /**
+ * Reads the object from the input stream, given the field
+ * definition.
+ *
+ * @param in the input stream
+ * @param fields the deserializer's own field marshal
+ * @return the new object
+ * @throws IOException
+ */
+ public Object readObject(AbstractHessianInput in,
+ Object []fields)
+ throws IOException;
+
+ public Object readObject(AbstractHessianInput in,
+ String []fieldNames)
+ throws IOException;
+}
diff --git a/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/EnumDeserializer.java b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/EnumDeserializer.java
new file mode 100644
index 0000000000..732c56d528
--- /dev/null
+++ b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/EnumDeserializer.java
@@ -0,0 +1,140 @@
+/*
+ * Copyright (c) 2001-2004 Caucho Technology, Inc. All rights reserved.
+ *
+ * The Apache Software License, Version 1.1
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. 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.
+ *
+ * 3. The end-user documentation included with the redistribution, if
+ * any, must include the following acknowlegement:
+ * "This product includes software developed by the
+ * Caucho Technology (http://www.caucho.com/)."
+ * Alternately, this acknowlegement may appear in the software itself,
+ * if and wherever such third-party acknowlegements normally appear.
+ *
+ * 4. The names "Hessian", "Resin", and "Caucho" must not be used to
+ * endorse or promote products derived from this software without prior
+ * written permission. For written permission, please contact
+ * info@caucho.com.
+ *
+ * 5. Products derived from this software may not be called "Resin"
+ * nor may "Resin" appear in their names without prior written
+ * permission of Caucho Technology.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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 CAUCHO TECHNOLOGY OR ITS 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.
+ *
+ * @author Scott Ferguson
+ */
+
+package com.caucho.hessian4.io;
+
+import java.io.IOException;
+import java.lang.reflect.Method;
+
+/**
+ * Deserializing an enum valued object
+ */
+public class EnumDeserializer extends AbstractDeserializer {
+ private Class _enumType;
+ private Method _valueOf;
+
+ public EnumDeserializer(Class cl)
+ {
+ // hessian/33b[34], hessian/3bb[78]
+ if (cl.isEnum())
+ _enumType = cl;
+ else if (cl.getSuperclass().isEnum())
+ _enumType = cl.getSuperclass();
+ else
+ throw new RuntimeException("Class " + cl.getName() + " is not an enum");
+
+ try {
+ _valueOf = _enumType.getMethod("valueOf",
+ new Class[] { Class.class, String.class });
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ public Class getType()
+ {
+ return _enumType;
+ }
+
+ public Object readMap(AbstractHessianInput in)
+ throws IOException
+ {
+ String name = null;
+
+ while (! in.isEnd()) {
+ String key = in.readString();
+
+ if (key.equals("name"))
+ name = in.readString();
+ else
+ in.readObject();
+ }
+
+ in.readMapEnd();
+
+ Object obj = create(name);
+
+ in.addRef(obj);
+
+ return obj;
+ }
+
+ @Override
+ public Object readObject(AbstractHessianInput in, Object []fields)
+ throws IOException
+ {
+ String []fieldNames = (String []) fields;
+ String name = null;
+
+ for (int i = 0; i < fieldNames.length; i++) {
+ if ("name".equals(fieldNames[i]))
+ name = in.readString();
+ else
+ in.readObject();
+ }
+
+ Object obj = create(name);
+
+ in.addRef(obj);
+
+ return obj;
+ }
+
+ private Object create(String name)
+ throws IOException
+ {
+ if (name == null)
+ throw new IOException(_enumType.getName() + " expects name.");
+
+ try {
+ return _valueOf.invoke(null, _enumType, name);
+ } catch (Exception e) {
+ throw new IOExceptionWrapper(e);
+ }
+ }
+}
diff --git a/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/EnumSerializer.java b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/EnumSerializer.java
new file mode 100644
index 0000000000..770a0230b3
--- /dev/null
+++ b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/EnumSerializer.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) 2001-2004 Caucho Technology, Inc. All rights reserved.
+ *
+ * The Apache Software License, Version 1.1
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. 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.
+ *
+ * 3. The end-user documentation included with the redistribution, if
+ * any, must include the following acknowlegement:
+ * "This product includes software developed by the
+ * Caucho Technology (http://www.caucho.com/)."
+ * Alternately, this acknowlegement may appear in the software itself,
+ * if and wherever such third-party acknowlegements normally appear.
+ *
+ * 4. The names "Burlap", "Resin", and "Caucho" must not be used to
+ * endorse or promote products derived from this software without prior
+ * written permission. For written permission, please contact
+ * info@caucho.com.
+ *
+ * 5. Products derived from this software may not be called "Resin"
+ * nor may "Resin" appear in their names without prior written
+ * permission of Caucho Technology.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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 CAUCHO TECHNOLOGY OR ITS 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.
+ *
+ * @author Scott Ferguson
+ */
+
+package com.caucho.hessian4.io;
+
+import java.io.IOException;
+import java.lang.reflect.Method;
+
+/**
+ * Serializing an object for known object types.
+ */
+public class EnumSerializer extends AbstractSerializer {
+ private Method _name;
+
+ public EnumSerializer(Class cl)
+ {
+ // hessian/32b[12], hessian/3ab[23]
+ if (! cl.isEnum() && cl.getSuperclass().isEnum())
+ cl = cl.getSuperclass();
+
+ try {
+ _name = cl.getMethod("name", new Class[0]);
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ public void writeObject(Object obj, AbstractHessianOutput out)
+ throws IOException
+ {
+ if (out.addRef(obj))
+ return;
+
+ Class cl = obj.getClass();
+
+ if (! cl.isEnum() && cl.getSuperclass().isEnum())
+ cl = cl.getSuperclass();
+
+ String name = null;
+ try {
+ name = (String) _name.invoke(obj, (Object[]) null);
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+
+ int ref = out.writeObjectBegin(cl.getName());
+
+ if (ref < -1) {
+ out.writeString("name");
+ out.writeString(name);
+ out.writeMapEnd();
+ }
+ else {
+ if (ref == -1) {
+ out.writeClassFieldLength(1);
+ out.writeString("name");
+ out.writeObjectBegin(cl.getName());
+ }
+
+ out.writeString(name);
+ }
+ }
+}
diff --git a/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/EnumerationDeserializer.java b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/EnumerationDeserializer.java
new file mode 100644
index 0000000000..ecaf8e4151
--- /dev/null
+++ b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/EnumerationDeserializer.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2001-2004 Caucho Technology, Inc. All rights reserved.
+ *
+ * The Apache Software License, Version 1.1
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. 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.
+ *
+ * 3. The end-user documentation included with the redistribution, if
+ * any, must include the following acknowlegement:
+ * "This product includes software developed by the
+ * Caucho Technology (http://www.caucho.com/)."
+ * Alternately, this acknowlegement may appear in the software itself,
+ * if and wherever such third-party acknowlegements normally appear.
+ *
+ * 4. The names "Hessian", "Resin", and "Caucho" must not be used to
+ * endorse or promote products derived from this software without prior
+ * written permission. For written permission, please contact
+ * info@caucho.com.
+ *
+ * 5. Products derived from this software may not be called "Resin"
+ * nor may "Resin" appear in their names without prior written
+ * permission of Caucho Technology.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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 CAUCHO TECHNOLOGY OR ITS 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.
+ *
+ * @author Scott Ferguson
+ */
+
+package com.caucho.hessian4.io;
+
+import java.io.IOException;
+import java.util.Vector;
+
+/**
+ * Deserializing a JDK 1.2 Collection.
+ */
+public class EnumerationDeserializer extends AbstractListDeserializer {
+ private static EnumerationDeserializer _deserializer;
+
+ public static EnumerationDeserializer create()
+ {
+ if (_deserializer == null)
+ _deserializer = new EnumerationDeserializer();
+
+ return _deserializer;
+ }
+
+ public Object readList(AbstractHessianInput in, int length)
+ throws IOException
+ {
+ Vector list = new Vector();
+
+ in.addRef(list);
+
+ while (! in.isEnd())
+ list.add(in.readObject());
+
+ in.readEnd();
+
+ return list.elements();
+ }
+}
+
+
diff --git a/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/EnumerationSerializer.java b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/EnumerationSerializer.java
new file mode 100644
index 0000000000..56f0993e8b
--- /dev/null
+++ b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/EnumerationSerializer.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2001-2004 Caucho Technology, Inc. All rights reserved.
+ *
+ * The Apache Software License, Version 1.1
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. 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.
+ *
+ * 3. The end-user documentation included with the redistribution, if
+ * any, must include the following acknowlegement:
+ * "This product includes software developed by the
+ * Caucho Technology (http://www.caucho.com/)."
+ * Alternately, this acknowlegement may appear in the software itself,
+ * if and wherever such third-party acknowlegements normally appear.
+ *
+ * 4. The names "Hessian", "Resin", and "Caucho" must not be used to
+ * endorse or promote products derived from this software without prior
+ * written permission. For written permission, please contact
+ * info@caucho.com.
+ *
+ * 5. Products derived from this software may not be called "Resin"
+ * nor may "Resin" appear in their names without prior written
+ * permission of Caucho Technology.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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 CAUCHO TECHNOLOGY OR ITS 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.
+ *
+ * @author Scott Ferguson
+ */
+
+package com.caucho.hessian4.io;
+
+import java.io.IOException;
+import java.util.Enumeration;
+
+/**
+ * Serializing a JDK 1.2 Enumeration.
+ */
+public class EnumerationSerializer extends AbstractSerializer {
+ private static EnumerationSerializer _serializer;
+
+ public static EnumerationSerializer create()
+ {
+ if (_serializer == null)
+ _serializer = new EnumerationSerializer();
+
+ return _serializer;
+ }
+
+ public void writeObject(Object obj, AbstractHessianOutput out)
+ throws IOException
+ {
+ Enumeration iter = (Enumeration) obj;
+
+ boolean hasEnd = out.writeListBegin(-1, null);
+
+ while (iter.hasMoreElements()) {
+ Object value = iter.nextElement();
+
+ out.writeObject(value);
+ }
+
+ if (hasEnd)
+ out.writeListEnd();
+ }
+}
diff --git a/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/EnvelopeFactory.java b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/EnvelopeFactory.java
new file mode 100644
index 0000000000..39a9c9f3df
--- /dev/null
+++ b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/EnvelopeFactory.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2001-2004 Caucho Technology, Inc. All rights reserved.
+ *
+ * The Apache Software License, Version 1.1
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. 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.
+ *
+ * 3. The end-user documentation included with the redistribution, if
+ * any, must include the following acknowlegement:
+ * "This product includes software developed by the
+ * Caucho Technology (http://www.caucho.com/)."
+ * Alternately, this acknowlegement may appear in the software itself,
+ * if and wherever such third-party acknowlegements normally appear.
+ *
+ * 4. The names "Hessian", "Resin", and "Caucho" must not be used to
+ * endorse or promote products derived from this software without prior
+ * written permission. For written permission, please contact
+ * info@caucho.com.
+ *
+ * 5. Products derived from this software may not be called "Resin"
+ * nor may "Resin" appear in their names without prior written
+ * permission of Caucho Technology.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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 CAUCHO TECHNOLOGY OR ITS 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.
+ *
+ * @author Scott Ferguson
+ */
+
+package com.caucho.hessian4.io;
+
+import java.util.logging.Logger;
+
+public class EnvelopeFactory
+{
+ private static final Logger log
+ = Logger.getLogger(EnvelopeFactory.class.getName());
+}
diff --git a/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/ExtSerializerFactory.java b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/ExtSerializerFactory.java
new file mode 100644
index 0000000000..95fc0813d2
--- /dev/null
+++ b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/ExtSerializerFactory.java
@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) 2001-2004 Caucho Technology, Inc. All rights reserved.
+ *
+ * The Apache Software License, Version 1.1
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. 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.
+ *
+ * 3. The end-user documentation included with the redistribution, if
+ * any, must include the following acknowlegement:
+ * "This product includes software developed by the
+ * Caucho Technology (http://www.caucho.com/)."
+ * Alternately, this acknowlegement may appear in the software itself,
+ * if and wherever such third-party acknowlegements normally appear.
+ *
+ * 4. The names "Burlap", "Resin", and "Caucho" must not be used to
+ * endorse or promote products derived from this software without prior
+ * written permission. For written permission, please contact
+ * info@caucho.com.
+ *
+ * 5. Products derived from this software may not be called "Resin"
+ * nor may "Resin" appear in their names without prior written
+ * permission of Caucho Technology.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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 CAUCHO TECHNOLOGY OR ITS 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.
+ *
+ * @author Scott Ferguson
+ */
+
+package com.caucho.hessian4.io;
+
+import java.util.HashMap;
+
+/**
+ * Factory for returning serialization methods.
+ */
+public class ExtSerializerFactory extends AbstractSerializerFactory {
+ private HashMap _serializerMap = new HashMap();
+ private HashMap _deserializerMap = new HashMap();
+
+ /**
+ * Adds a serializer.
+ *
+ * @param cl the class of the serializer
+ * @param serializer the serializer
+ */
+ public void addSerializer(Class cl, Serializer serializer)
+ {
+ _serializerMap.put(cl, serializer);
+ }
+
+ /**
+ * Adds a deserializer.
+ *
+ * @param cl the class of the deserializer
+ * @param deserializer the deserializer
+ */
+ public void addDeserializer(Class cl, Deserializer deserializer)
+ {
+ _deserializerMap.put(cl, deserializer);
+ }
+
+ /**
+ * Returns the serializer for a class.
+ *
+ * @param cl the class of the object that needs to be serialized.
+ *
+ * @return a serializer object for the serialization.
+ */
+ public Serializer getSerializer(Class cl)
+ throws HessianProtocolException
+ {
+ return (Serializer) _serializerMap.get(cl);
+ }
+
+ /**
+ * Returns the deserializer for a class.
+ *
+ * @param cl the class of the object that needs to be deserialized.
+ *
+ * @return a deserializer object for the serialization.
+ */
+ public Deserializer getDeserializer(Class cl)
+ throws HessianProtocolException
+ {
+ return (Deserializer) _deserializerMap.get(cl);
+ }
+}
diff --git a/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/FileDeserializer.java b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/FileDeserializer.java
new file mode 100644
index 0000000000..0948750a61
--- /dev/null
+++ b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/FileDeserializer.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2001-2004 Caucho Technology, Inc. All rights reserved.
+ *
+ * The Apache Software License, Version 1.1
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. 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.
+ *
+ * 3. The end-user documentation included with the redistribution, if
+ * any, must include the following acknowlegement:
+ * "This product includes software developed by the
+ * Caucho Technology (http://www.caucho.com/)."
+ * Alternately, this acknowlegement may appear in the software itself,
+ * if and wherever such third-party acknowlegements normally appear.
+ *
+ * 4. The names "Hessian", "Resin", and "Caucho" must not be used to
+ * endorse or promote products derived from this software without prior
+ * written permission. For written permission, please contact
+ * info@caucho.com.
+ *
+ * 5. Products derived from this software may not be called "Resin"
+ * nor may "Resin" appear in their names without prior written
+ * permission of Caucho Technology.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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 CAUCHO TECHNOLOGY OR ITS 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.
+ *
+ * @author Scott Ferguson
+ */
+
+package com.caucho.hessian4.io;
+
+import java.io.File;
+
+/**
+ * Deserializing a File
+ */
+public class FileDeserializer extends AbstractStringValueDeserializer {
+ @Override
+ public Class getType()
+ {
+ return File.class;
+ }
+
+ @Override
+ protected Object create(String value)
+ {
+ return new File(value);
+ }
+}
diff --git a/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/FloatHandle.java b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/FloatHandle.java
new file mode 100644
index 0000000000..f79821c6b9
--- /dev/null
+++ b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/FloatHandle.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) 2001-2004 Caucho Technology, Inc. All rights reserved.
+ *
+ * The Apache Software License, Version 1.1
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. 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.
+ *
+ * 3. The end-user documentation included with the redistribution, if
+ * any, must include the following acknowlegement:
+ * "This product includes software developed by the
+ * Caucho Technology (http://www.caucho.com/)."
+ * Alternately, this acknowlegement may appear in the software itself,
+ * if and wherever such third-party acknowlegements normally appear.
+ *
+ * 4. The names "Burlap", "Resin", and "Caucho" must not be used to
+ * endorse or promote products derived from this software without prior
+ * written permission. For written permission, please contact
+ * info@caucho.com.
+ *
+ * 5. Products derived from this software may not be called "Resin"
+ * nor may "Resin" appear in their names without prior written
+ * permission of Caucho Technology.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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 CAUCHO TECHNOLOGY OR ITS 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.
+ *
+ * @author Scott Ferguson
+ */
+
+package com.caucho.hessian4.io;
+
+import java.io.Serializable;
+
+/**
+ * Handle for Java Float objects.
+ */
+public class FloatHandle implements Serializable {
+ private float _value;
+
+ private FloatHandle()
+ {
+ }
+
+ public FloatHandle(float value)
+ {
+ _value = value;
+ }
+
+ public float getValue()
+ {
+ return _value;
+ }
+
+ public Object readResolve()
+ {
+ return new Float(_value);
+ }
+
+ public String toString()
+ {
+ return getClass().getSimpleName() + "[" + _value + "]";
+ }
+}
diff --git a/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/FlushableOutput.java b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/FlushableOutput.java
new file mode 100644
index 0000000000..3c5547ad56
--- /dev/null
+++ b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/FlushableOutput.java
@@ -0,0 +1,12 @@
+package com.caucho.hessian4.io;
+
+import java.io.IOException;
+
+import org.jboss.netty.channel.ChannelFuture;
+
+public interface FlushableOutput
+{
+ public void flush(ChannelFuture future) throws IOException;
+ public void reset();
+
+}
diff --git a/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/Hessian2Constants.java b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/Hessian2Constants.java
new file mode 100644
index 0000000000..6e7ee88ec7
--- /dev/null
+++ b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/Hessian2Constants.java
@@ -0,0 +1,146 @@
+/*
+ * Copyright (c) 2001-2008 Caucho Technology, Inc. All rights reserved.
+ *
+ * The Apache Software License, Version 1.1
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. 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.
+ *
+ * 3. The end-user documentation included with the redistribution, if
+ * any, must include the following acknowlegement:
+ * "This product includes software developed by the
+ * Caucho Technology (http://www.caucho.com/)."
+ * Alternately, this acknowlegement may appear in the software itself,
+ * if and wherever such third-party acknowlegements normally appear.
+ *
+ * 4. The names "Burlap", "Resin", and "Caucho" must not be used to
+ * endorse or promote products derived from this software without prior
+ * written permission. For written permission, please contact
+ * info@caucho.com.
+ *
+ * 5. Products derived from this software may not be called "Resin"
+ * nor may "Resin" appear in their names without prior written
+ * permission of Caucho Technology.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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 CAUCHO TECHNOLOGY OR ITS 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.
+ *
+ * @author Scott Ferguson
+ */
+
+package com.caucho.hessian4.io;
+
+public interface Hessian2Constants
+{
+ public static final int BC_BINARY = 'B'; // final chunk
+ public static final int BC_BINARY_CHUNK = 'A'; // non-final chunk
+ public static final int BC_BINARY_DIRECT = 0x20; // 1-byte length binary
+ public static final int BINARY_DIRECT_MAX = 0x0f;
+ public static final int BC_BINARY_SHORT = 0x34; // 2-byte length binary
+ public static final int BINARY_SHORT_MAX = 0x3ff; // 0-1023 binary
+
+ public static final int BC_CLASS_DEF = 'C'; // object/class definition
+
+ public static final int BC_DATE = 0x4a; // 64-bit millisecond UTC date
+ public static final int BC_DATE_MINUTE = 0x4b; // 32-bit minute UTC date
+
+ public static final int BC_DOUBLE = 'D'; // IEEE 64-bit double
+
+ public static final int BC_DOUBLE_ZERO = 0x5b;
+ public static final int BC_DOUBLE_ONE = 0x5c;
+ public static final int BC_DOUBLE_BYTE = 0x5d;
+ public static final int BC_DOUBLE_SHORT = 0x5e;
+ public static final int BC_DOUBLE_MILL = 0x5f;
+
+ public static final int BC_FALSE = 'F'; // boolean false
+
+ public static final int BC_INT = 'I'; // 32-bit int
+
+ public static final int INT_DIRECT_MIN = -0x10;
+ public static final int INT_DIRECT_MAX = 0x2f;
+ public static final int BC_INT_ZERO = 0x90;
+
+ public static final int INT_BYTE_MIN = -0x800;
+ public static final int INT_BYTE_MAX = 0x7ff;
+ public static final int BC_INT_BYTE_ZERO = 0xc8;
+
+ public static final int BC_END = 'Z';
+
+ public static final int INT_SHORT_MIN = -0x40000;
+ public static final int INT_SHORT_MAX = 0x3ffff;
+ public static final int BC_INT_SHORT_ZERO = 0xd4;
+
+ public static final int BC_LIST_VARIABLE =0x55;
+ public static final int BC_LIST_FIXED = 'V';
+ public static final int BC_LIST_VARIABLE_UNTYPED = 0x57;
+ public static final int BC_LIST_FIXED_UNTYPED =0x58;
+
+ public static final int BC_LIST_DIRECT = 0x70;
+ public static final int BC_LIST_DIRECT_UNTYPED = 0x78;
+ public static final int LIST_DIRECT_MAX = 0x7;
+
+ public static final int BC_LONG = 'L'; // 64-bit signed integer
+ public static final long LONG_DIRECT_MIN = -0x08;
+ public static final long LONG_DIRECT_MAX = 0x0f;
+ public static final int BC_LONG_ZERO = 0xe0;
+
+ public static final long LONG_BYTE_MIN = -0x800;
+ public static final long LONG_BYTE_MAX = 0x7ff;
+ public static final int BC_LONG_BYTE_ZERO = 0xf8;
+
+ public static final int LONG_SHORT_MIN = -0x40000;
+ public static final int LONG_SHORT_MAX = 0x3ffff;
+ public static final int BC_LONG_SHORT_ZERO = 0x3c;
+
+ public static final int BC_LONG_INT = 0x59;
+
+ public static final int BC_MAP = 'M';
+ public static final int BC_MAP_UNTYPED = 'H';
+
+ public static final int BC_NULL = 'N';
+
+ public static final int BC_OBJECT = 'O';
+ public static final int BC_OBJECT_DEF = 'C';
+
+ public static final int BC_OBJECT_DIRECT = 0x60;
+ public static final int OBJECT_DIRECT_MAX = 0x0f;
+
+ public static final int BC_REF = 0x51;
+
+ public static final int BC_STRING = 'S'; // final string
+ public static final int BC_STRING_CHUNK = 'R'; // non-final string
+
+ public static final int BC_STRING_DIRECT = 0x00;
+ public static final int STRING_DIRECT_MAX = 0x1f;
+ public static final int BC_STRING_SHORT = 0x30;
+ public static final int STRING_SHORT_MAX = 0x3ff;
+
+ public static final int BC_TRUE = 'T';
+
+ public static final int P_PACKET_CHUNK = 0x4f;
+ public static final int P_PACKET = 'P';
+
+ public static final int P_PACKET_DIRECT = 0x80;
+ public static final int PACKET_DIRECT_MAX = 0x7f;
+
+ public static final int P_PACKET_SHORT = 0x70;
+ public static final int PACKET_SHORT_MAX = 0xfff;
+}
diff --git a/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/Hessian2Input.java b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/Hessian2Input.java
new file mode 100644
index 0000000000..45a5d037f7
--- /dev/null
+++ b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/Hessian2Input.java
@@ -0,0 +1,2984 @@
+/*
+ * Copyright (c) 2001-2008 Caucho Technology, Inc. All rights reserved.
+ *
+ * The Apache Software License, Version 1.1
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. 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.
+ *
+ * 3. The end-user documentation included with the redistribution, if
+ * any, must include the following acknowlegement:
+ * "This product includes software developed by the
+ * Caucho Technology (http://www.caucho.com/)."
+ * Alternately, this acknowlegement may appear in the software itself,
+ * if and wherever such third-party acknowlegements normally appear.
+ *
+ * 4. The names "Hessian", "Resin", and "Caucho" must not be used to
+ * endorse or promote products derived from this software without prior
+ * written permission. For written permission, please contact
+ * info@caucho.com.
+ *
+ * 5. Products derived from this software may not be called "Resin"
+ * nor may "Resin" appear in their names without prior written
+ * permission of Caucho Technology.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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 CAUCHO TECHNOLOGY OR ITS 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.
+ *
+ * @author Scott Ferguson
+ */
+
+package com.caucho.hessian4.io;
+
+import java.io.ByteArrayOutputStream;
+import java.io.EOFException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.Reader;
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * Input stream for Hessian requests.
+ *
+ * HessianInput is unbuffered, so any client needs to provide
+ * its own buffering.
+ *
+ *
+ * InputStream is = ...; // from http connection
+ * HessianInput in = new HessianInput(is);
+ * String value;
+ *
+ * in.startReply(); // read reply header
+ * value = in.readString(); // read string value
+ * in.completeReply(); // read reply footer
+ *
+ */
+public class Hessian2Input
+ extends AbstractHessianInput
+ implements Hessian2Constants
+{
+ private static final Logger log
+ = Logger.getLogger(Hessian2Input.class.getName());
+
+ private static final int END_OF_DATA = -2;
+
+ private static Field _detailMessageField;
+
+ private static final int SIZE = 1024*1024;
+ private static final int GAP = 16;
+
+ // standard, unmodified factory for deserializing objects
+ protected SerializerFactory _defaultSerializerFactory;
+ // factory for deserializing objects in the input stream
+ protected SerializerFactory _serializerFactory;
+
+ private static boolean _isCloseStreamOnClose;
+
+ protected ArrayList _refs
+ = new ArrayList();
+ protected ArrayList _classDefs
+ = new ArrayList();
+ protected ArrayList _types
+ = new ArrayList();
+
+ // the underlying input stream
+ volatile protected InputStream _is;
+ private final byte []_buffer = new byte[SIZE];
+
+ // a peek character
+ protected int _offset;
+ protected int _length;
+
+ // the method for a call
+ private String _method;
+ private Throwable _replyFault;
+
+ private StringBuffer _sbuf = new StringBuffer();
+
+ // true if this is the last chunk
+ private boolean _isLastChunk;
+ // the chunk length
+ private int _chunkLength;
+
+ /**
+ * Creates a new Hessian input stream, initialized with an
+ * underlying input stream.
+ *
+ * @param is the underlying input stream.
+ */
+ public Hessian2Input(InputStream is)
+ {
+ _is = is;
+ }
+
+ /**
+ * Sets the serializer factory.
+ */
+ public void setSerializerFactory(SerializerFactory factory)
+ {
+ _serializerFactory = factory;
+ }
+
+ /**
+ * Gets the serializer factory.
+ */
+ public SerializerFactory getSerializerFactory()
+ {
+ // the default serializer factory cannot be modified by external
+ // callers
+ if (_serializerFactory == _defaultSerializerFactory) {
+ _serializerFactory = new SerializerFactory();
+ }
+
+ return _serializerFactory;
+ }
+
+ /**
+ * Gets the serializer factory.
+ */
+ protected final SerializerFactory findSerializerFactory()
+ {
+ SerializerFactory factory = _serializerFactory;
+
+ if (factory == null) {
+ factory = SerializerFactory.createDefault();
+ _defaultSerializerFactory = factory;
+ _serializerFactory = factory;
+ }
+
+ return factory;
+ }
+
+ public void setCloseStreamOnClose(boolean isClose)
+ {
+ _isCloseStreamOnClose = isClose;
+ }
+
+ public boolean isCloseStreamOnClose()
+ {
+ return _isCloseStreamOnClose;
+ }
+
+ /**
+ * Returns the calls method
+ */
+ public String getMethod()
+ {
+ return _method;
+ }
+
+ /**
+ * Returns any reply fault.
+ */
+ public Throwable getReplyFault()
+ {
+ return _replyFault;
+ }
+
+ /**
+ * Starts reading the call
+ *
+ *
+ * c major minor
+ *
+ */
+ public int readCall()
+ throws IOException
+ {
+ int tag = read();
+
+ if (tag != 'C')
+ throw error("expected hessian call ('C') at " + codeName(tag));
+
+ return 0;
+ }
+
+ /**
+ * Starts reading the envelope
+ *
+ *
+ * E major minor
+ *
+ */
+ public int readEnvelope()
+ throws IOException
+ {
+ int tag = read();
+ int version = 0;
+
+ if (tag == 'H') {
+ int major = read();
+ int minor = read();
+
+ version = (major << 16) + minor;
+
+ tag = read();
+ }
+
+ if (tag != 'E')
+ throw error("expected hessian Envelope ('E') at " + codeName(tag));
+
+ return version;
+ }
+
+ /**
+ * Completes reading the envelope
+ *
+ * A successful completion will have a single value:
+ *
+ *
+ * Z
+ *
+ */
+ public void completeEnvelope()
+ throws IOException
+ {
+ int tag = read();
+
+ if (tag != 'Z')
+ error("expected end of envelope at " + codeName(tag));
+ }
+
+ /**
+ * Starts reading the call
+ *
+ * A successful completion will have a single value:
+ *
+ *
+ * string
+ *
+ */
+ public String readMethod()
+ throws IOException
+ {
+ _method = readString();
+
+ return _method;
+ }
+
+ /**
+ * Returns the number of method arguments
+ *
+ *
+ * int
+ *
+ */
+ @Override
+ public int readMethodArgLength()
+ throws IOException
+ {
+ return readInt();
+ }
+
+ /**
+ * Starts reading the call, including the headers.
+ *
+ * The call expects the following protocol data
+ *
+ *
+ * c major minor
+ * m b16 b8 method
+ *
+ */
+ public void startCall()
+ throws IOException
+ {
+ readCall();
+
+ readMethod();
+ }
+
+ public Object []readArguments()
+ throws IOException
+ {
+ int len = readInt();
+
+ Object []args = new Object[len];
+
+ for (int i = 0; i < len; i++)
+ args[i] = readObject();
+
+ return args;
+ }
+
+ /**
+ * Completes reading the call
+ *
+ * A successful completion will have a single value:
+ *
+ *
+ *
+ */
+ public void completeCall()
+ throws IOException
+ {
+ }
+
+ /**
+ * Reads a reply as an object.
+ * If the reply has a fault, throws the exception.
+ */
+ @Override
+ public Object readReply(Class expectedClass)
+ throws Throwable
+ {
+ int tag = read();
+
+ if (tag == 'R')
+ return readObject(expectedClass);
+ else if (tag == 'F') {
+ HashMap map = (HashMap) readObject(HashMap.class);
+
+ throw prepareFault(map);
+ }
+ else {
+ StringBuilder sb = new StringBuilder();
+ sb.append((char) tag);
+
+ try {
+ int ch;
+
+ while ((ch = read()) >= 0) {
+ sb.append((char) ch);
+ }
+ } catch (IOException e) {
+ log.log(Level.FINE, e.toString(), e);
+ }
+
+ throw error("expected hessian reply at " + codeName(tag) + "\n"
+ + sb);
+ }
+ }
+
+ /**
+ * Starts reading the reply
+ *
+ * A successful completion will have a single value:
+ *
+ *
+ * r
+ *
+ */
+ public void startReply()
+ throws Throwable
+ {
+ // XXX: for variable length (?)
+
+ readReply(Object.class);
+ }
+
+ /**
+ * Prepares the fault.
+ */
+ private Throwable prepareFault(HashMap fault)
+ throws IOException
+ {
+ Object detail = fault.get("detail");
+ String message = (String) fault.get("message");
+
+ if (detail instanceof Throwable) {
+ _replyFault = (Throwable) detail;
+
+ if (message != null && _detailMessageField != null) {
+ try {
+ _detailMessageField.set(_replyFault, message);
+ } catch (Throwable e) {
+ }
+ }
+
+ return _replyFault;
+ }
+
+ else {
+ String code = (String) fault.get("code");
+
+ _replyFault = new HessianServiceException(message, code, detail);
+
+ return _replyFault;
+ }
+ }
+
+ /**
+ * Completes reading the call
+ *
+ * A successful completion will have a single value:
+ *
+ *
+ * z
+ *
+ */
+ public void completeReply()
+ throws IOException
+ {
+ }
+
+ /**
+ * Completes reading the call
+ *
+ * A successful completion will have a single value:
+ *
+ *
+ * z
+ *
+ */
+ public void completeValueReply()
+ throws IOException
+ {
+ int tag = read();
+
+ if (tag != 'Z')
+ error("expected end of reply at " + codeName(tag));
+ }
+
+ /**
+ * Reads a header, returning null if there are no headers.
+ *
+ *
+ * H b16 b8 value
+ *
+ */
+ public String readHeader()
+ throws IOException
+ {
+ return null;
+ }
+
+ /**
+ * Starts reading a packet
+ *
+ *
+ * p major minor
+ *
+ */
+ public int startMessage()
+ throws IOException
+ {
+ int tag = read();
+
+ if (tag == 'p') {
+ } else if (tag == 'P') {
+ } else
+ throw error("expected Hessian message ('p') at " + codeName(tag));
+
+ int major = read();
+ int minor = read();
+
+ return (major << 16) + minor;
+ }
+
+ /**
+ * Completes reading the message
+ *
+ * A successful completion will have a single value:
+ *
+ *
+ * z
+ *
+ */
+ public void completeMessage()
+ throws IOException
+ {
+ int tag = read();
+
+ if (tag != 'Z')
+ error("expected end of message at " + codeName(tag));
+ }
+
+ /**
+ * Reads a null
+ *
+ *
+ * N
+ *
+ */
+ public void readNull()
+ throws IOException
+ {
+ int tag = read();
+
+ switch (tag) {
+ case 'N': return;
+
+ default:
+ throw expect("null", tag);
+ }
+ }
+
+ /**
+ * Reads a boolean
+ *
+ *
+ * T
+ * F
+ *
+ */
+ public boolean readBoolean()
+ throws IOException
+ {
+ int tag = _offset < _length ? (_buffer[_offset++] & 0xff) : read();
+
+ switch (tag) {
+ case 'T': return true;
+ case 'F': return false;
+
+ // direct integer
+ case 0x80: case 0x81: case 0x82: case 0x83:
+ case 0x84: case 0x85: case 0x86: case 0x87:
+ case 0x88: case 0x89: case 0x8a: case 0x8b:
+ case 0x8c: case 0x8d: case 0x8e: case 0x8f:
+
+ case 0x90: case 0x91: case 0x92: case 0x93:
+ case 0x94: case 0x95: case 0x96: case 0x97:
+ case 0x98: case 0x99: case 0x9a: case 0x9b:
+ case 0x9c: case 0x9d: case 0x9e: case 0x9f:
+
+ case 0xa0: case 0xa1: case 0xa2: case 0xa3:
+ case 0xa4: case 0xa5: case 0xa6: case 0xa7:
+ case 0xa8: case 0xa9: case 0xaa: case 0xab:
+ case 0xac: case 0xad: case 0xae: case 0xaf:
+
+ case 0xb0: case 0xb1: case 0xb2: case 0xb3:
+ case 0xb4: case 0xb5: case 0xb6: case 0xb7:
+ case 0xb8: case 0xb9: case 0xba: case 0xbb:
+ case 0xbc: case 0xbd: case 0xbe: case 0xbf:
+ return tag != BC_INT_ZERO;
+
+ // INT_BYTE = 0
+ case 0xc8:
+ return read() != 0;
+
+ // INT_BYTE != 0
+ case 0xc0: case 0xc1: case 0xc2: case 0xc3:
+ case 0xc4: case 0xc5: case 0xc6: case 0xc7:
+ case 0xc9: case 0xca: case 0xcb:
+ case 0xcc: case 0xcd: case 0xce: case 0xcf:
+ read();
+ return true;
+
+ // INT_SHORT = 0
+ case 0xd4:
+ return (256 * read() + read()) != 0;
+
+ // INT_SHORT != 0
+ case 0xd0: case 0xd1: case 0xd2: case 0xd3:
+ case 0xd5: case 0xd6: case 0xd7:
+ read();
+ read();
+ return true;
+
+ case 'I': return
+ parseInt() != 0;
+
+ case 0xd8: case 0xd9: case 0xda: case 0xdb:
+ case 0xdc: case 0xdd: case 0xde: case 0xdf:
+
+ case 0xe0: case 0xe1: case 0xe2: case 0xe3:
+ case 0xe4: case 0xe5: case 0xe6: case 0xe7:
+ case 0xe8: case 0xe9: case 0xea: case 0xeb:
+ case 0xec: case 0xed: case 0xee: case 0xef:
+ return tag != BC_LONG_ZERO;
+
+ // LONG_BYTE = 0
+ case 0xf8:
+ return read() != 0;
+
+ // LONG_BYTE != 0
+ case 0xf0: case 0xf1: case 0xf2: case 0xf3:
+ case 0xf4: case 0xf5: case 0xf6: case 0xf7:
+ case 0xf9: case 0xfa: case 0xfb:
+ case 0xfc: case 0xfd: case 0xfe: case 0xff:
+ read();
+ return true;
+
+ // INT_SHORT = 0
+ case 0x3c:
+ return (256 * read() + read()) != 0;
+
+ // INT_SHORT != 0
+ case 0x38: case 0x39: case 0x3a: case 0x3b:
+ case 0x3d: case 0x3e: case 0x3f:
+ read();
+ read();
+ return true;
+
+ case BC_LONG_INT:
+ return (0x1000000L * read()
+ + 0x10000L * read()
+ + 0x100 * read()
+ + read()) != 0;
+
+ case 'L':
+ return parseLong() != 0;
+
+ case BC_DOUBLE_ZERO:
+ return false;
+
+ case BC_DOUBLE_ONE:
+ return true;
+
+ case BC_DOUBLE_BYTE:
+ return read() != 0;
+
+ case BC_DOUBLE_SHORT:
+ return (0x100 * read() + read()) != 0;
+
+ case BC_DOUBLE_MILL:
+ {
+ int mills = parseInt();
+
+ return mills != 0;
+ }
+
+ case 'D':
+ return parseDouble() != 0.0;
+
+ case 'N':
+ return false;
+
+ default:
+ throw expect("boolean", tag);
+ }
+ }
+
+ /**
+ * Reads a short
+ *
+ *
+ * I b32 b24 b16 b8
+ *
+ */
+ public short readShort()
+ throws IOException
+ {
+ return (short) readInt();
+ }
+
+ /**
+ * Reads an integer
+ *
+ *
+ * I b32 b24 b16 b8
+ *
+ */
+ public final int readInt()
+ throws IOException
+ {
+ //int tag = _offset < _length ? (_buffer[_offset++] & 0xff) : read();
+ int tag = read();
+
+ switch (tag) {
+ case 'N':
+ return 0;
+
+ case 'F':
+ return 0;
+
+ case 'T':
+ return 1;
+
+ // direct integer
+ case 0x80: case 0x81: case 0x82: case 0x83:
+ case 0x84: case 0x85: case 0x86: case 0x87:
+ case 0x88: case 0x89: case 0x8a: case 0x8b:
+ case 0x8c: case 0x8d: case 0x8e: case 0x8f:
+
+ case 0x90: case 0x91: case 0x92: case 0x93:
+ case 0x94: case 0x95: case 0x96: case 0x97:
+ case 0x98: case 0x99: case 0x9a: case 0x9b:
+ case 0x9c: case 0x9d: case 0x9e: case 0x9f:
+
+ case 0xa0: case 0xa1: case 0xa2: case 0xa3:
+ case 0xa4: case 0xa5: case 0xa6: case 0xa7:
+ case 0xa8: case 0xa9: case 0xaa: case 0xab:
+ case 0xac: case 0xad: case 0xae: case 0xaf:
+
+ case 0xb0: case 0xb1: case 0xb2: case 0xb3:
+ case 0xb4: case 0xb5: case 0xb6: case 0xb7:
+ case 0xb8: case 0xb9: case 0xba: case 0xbb:
+ case 0xbc: case 0xbd: case 0xbe: case 0xbf:
+ return tag - BC_INT_ZERO;
+
+ /* byte int */
+ case 0xc0: case 0xc1: case 0xc2: case 0xc3:
+ case 0xc4: case 0xc5: case 0xc6: case 0xc7:
+ case 0xc8: case 0xc9: case 0xca: case 0xcb:
+ case 0xcc: case 0xcd: case 0xce: case 0xcf:
+ return ((tag - BC_INT_BYTE_ZERO) << 8) + read();
+
+ /* short int */
+ case 0xd0: case 0xd1: case 0xd2: case 0xd3:
+ case 0xd4: case 0xd5: case 0xd6: case 0xd7:
+ return ((tag - BC_INT_SHORT_ZERO) << 16) + 256 * read() + read();
+
+ case 'I':
+ case BC_LONG_INT:
+ return ((read() << 24)
+ + (read() << 16)
+ + (read() << 8)
+ + read());
+
+ // direct long
+ case 0xd8: case 0xd9: case 0xda: case 0xdb:
+ case 0xdc: case 0xdd: case 0xde: case 0xdf:
+
+ case 0xe0: case 0xe1: case 0xe2: case 0xe3:
+ case 0xe4: case 0xe5: case 0xe6: case 0xe7:
+ case 0xe8: case 0xe9: case 0xea: case 0xeb:
+ case 0xec: case 0xed: case 0xee: case 0xef:
+ return tag - BC_LONG_ZERO;
+
+ /* byte long */
+ case 0xf0: case 0xf1: case 0xf2: case 0xf3:
+ case 0xf4: case 0xf5: case 0xf6: case 0xf7:
+ case 0xf8: case 0xf9: case 0xfa: case 0xfb:
+ case 0xfc: case 0xfd: case 0xfe: case 0xff:
+ return ((tag - BC_LONG_BYTE_ZERO) << 8) + read();
+
+ /* short long */
+ case 0x38: case 0x39: case 0x3a: case 0x3b:
+ case 0x3c: case 0x3d: case 0x3e: case 0x3f:
+ return ((tag - BC_LONG_SHORT_ZERO) << 16) + 256 * read() + read();
+
+ case 'L':
+ return (int) parseLong();
+
+ case BC_DOUBLE_ZERO:
+ return 0;
+
+ case BC_DOUBLE_ONE:
+ return 1;
+
+ //case LONG_BYTE:
+ case BC_DOUBLE_BYTE:
+ return (byte) (_offset < _length ? _buffer[_offset++] : read());
+
+ //case INT_SHORT:
+ //case LONG_SHORT:
+ case BC_DOUBLE_SHORT:
+ return (short) (256 * read() + read());
+
+ case BC_DOUBLE_MILL:
+ {
+ int mills = parseInt();
+
+ return (int) (0.001 * mills);
+ }
+
+ case 'D':
+ return (int) parseDouble();
+
+ default:
+ throw expect("integer", tag);
+ }
+ }
+
+ /**
+ * Reads a long
+ *
+ *
+ * L b64 b56 b48 b40 b32 b24 b16 b8
+ *
+ */
+ public long readLong()
+ throws IOException
+ {
+ int tag = read();
+
+ switch (tag) {
+ case 'N':
+ return 0;
+
+ case 'F':
+ return 0;
+
+ case 'T':
+ return 1;
+
+ // direct integer
+ case 0x80: case 0x81: case 0x82: case 0x83:
+ case 0x84: case 0x85: case 0x86: case 0x87:
+ case 0x88: case 0x89: case 0x8a: case 0x8b:
+ case 0x8c: case 0x8d: case 0x8e: case 0x8f:
+
+ case 0x90: case 0x91: case 0x92: case 0x93:
+ case 0x94: case 0x95: case 0x96: case 0x97:
+ case 0x98: case 0x99: case 0x9a: case 0x9b:
+ case 0x9c: case 0x9d: case 0x9e: case 0x9f:
+
+ case 0xa0: case 0xa1: case 0xa2: case 0xa3:
+ case 0xa4: case 0xa5: case 0xa6: case 0xa7:
+ case 0xa8: case 0xa9: case 0xaa: case 0xab:
+ case 0xac: case 0xad: case 0xae: case 0xaf:
+
+ case 0xb0: case 0xb1: case 0xb2: case 0xb3:
+ case 0xb4: case 0xb5: case 0xb6: case 0xb7:
+ case 0xb8: case 0xb9: case 0xba: case 0xbb:
+ case 0xbc: case 0xbd: case 0xbe: case 0xbf:
+ return tag - BC_INT_ZERO;
+
+ /* byte int */
+ case 0xc0: case 0xc1: case 0xc2: case 0xc3:
+ case 0xc4: case 0xc5: case 0xc6: case 0xc7:
+ case 0xc8: case 0xc9: case 0xca: case 0xcb:
+ case 0xcc: case 0xcd: case 0xce: case 0xcf:
+ return ((tag - BC_INT_BYTE_ZERO) << 8) + read();
+
+ /* short int */
+ case 0xd0: case 0xd1: case 0xd2: case 0xd3:
+ case 0xd4: case 0xd5: case 0xd6: case 0xd7:
+ return ((tag - BC_INT_SHORT_ZERO) << 16) + 256 * read() + read();
+
+ //case LONG_BYTE:
+ case BC_DOUBLE_BYTE:
+ return (byte) (_offset < _length ? _buffer[_offset++] : read());
+
+ //case INT_SHORT:
+ //case LONG_SHORT:
+ case BC_DOUBLE_SHORT:
+ return (short) (256 * read() + read());
+
+ case 'I':
+ case BC_LONG_INT:
+ return parseInt();
+
+ // direct long
+ case 0xd8: case 0xd9: case 0xda: case 0xdb:
+ case 0xdc: case 0xdd: case 0xde: case 0xdf:
+
+ case 0xe0: case 0xe1: case 0xe2: case 0xe3:
+ case 0xe4: case 0xe5: case 0xe6: case 0xe7:
+ case 0xe8: case 0xe9: case 0xea: case 0xeb:
+ case 0xec: case 0xed: case 0xee: case 0xef:
+ return tag - BC_LONG_ZERO;
+
+ /* byte long */
+ case 0xf0: case 0xf1: case 0xf2: case 0xf3:
+ case 0xf4: case 0xf5: case 0xf6: case 0xf7:
+ case 0xf8: case 0xf9: case 0xfa: case 0xfb:
+ case 0xfc: case 0xfd: case 0xfe: case 0xff:
+ return ((tag - BC_LONG_BYTE_ZERO) << 8) + read();
+
+ /* short long */
+ case 0x38: case 0x39: case 0x3a: case 0x3b:
+ case 0x3c: case 0x3d: case 0x3e: case 0x3f:
+ return ((tag - BC_LONG_SHORT_ZERO) << 16) + 256 * read() + read();
+
+ case 'L':
+ return parseLong();
+
+ case BC_DOUBLE_ZERO:
+ return 0;
+
+ case BC_DOUBLE_ONE:
+ return 1;
+
+ case BC_DOUBLE_MILL:
+ {
+ int mills = parseInt();
+
+ return (long) (0.001 * mills);
+ }
+
+ case 'D':
+ return (long) parseDouble();
+
+ default:
+ throw expect("long", tag);
+ }
+ }
+
+ /**
+ * Reads a float
+ *
+ *
+ * D b64 b56 b48 b40 b32 b24 b16 b8
+ *
+ */
+ public float readFloat()
+ throws IOException
+ {
+ return (float) readDouble();
+ }
+
+ /**
+ * Reads a double
+ *
+ *
+ * D b64 b56 b48 b40 b32 b24 b16 b8
+ *
+ */
+ public double readDouble()
+ throws IOException
+ {
+ int tag = read();
+
+ switch (tag) {
+ case 'N':
+ return 0;
+
+ case 'F':
+ return 0;
+
+ case 'T':
+ return 1;
+
+ // direct integer
+ case 0x80: case 0x81: case 0x82: case 0x83:
+ case 0x84: case 0x85: case 0x86: case 0x87:
+ case 0x88: case 0x89: case 0x8a: case 0x8b:
+ case 0x8c: case 0x8d: case 0x8e: case 0x8f:
+
+ case 0x90: case 0x91: case 0x92: case 0x93:
+ case 0x94: case 0x95: case 0x96: case 0x97:
+ case 0x98: case 0x99: case 0x9a: case 0x9b:
+ case 0x9c: case 0x9d: case 0x9e: case 0x9f:
+
+ case 0xa0: case 0xa1: case 0xa2: case 0xa3:
+ case 0xa4: case 0xa5: case 0xa6: case 0xa7:
+ case 0xa8: case 0xa9: case 0xaa: case 0xab:
+ case 0xac: case 0xad: case 0xae: case 0xaf:
+
+ case 0xb0: case 0xb1: case 0xb2: case 0xb3:
+ case 0xb4: case 0xb5: case 0xb6: case 0xb7:
+ case 0xb8: case 0xb9: case 0xba: case 0xbb:
+ case 0xbc: case 0xbd: case 0xbe: case 0xbf:
+ return tag - 0x90;
+
+ /* byte int */
+ case 0xc0: case 0xc1: case 0xc2: case 0xc3:
+ case 0xc4: case 0xc5: case 0xc6: case 0xc7:
+ case 0xc8: case 0xc9: case 0xca: case 0xcb:
+ case 0xcc: case 0xcd: case 0xce: case 0xcf:
+ return ((tag - BC_INT_BYTE_ZERO) << 8) + read();
+
+ /* short int */
+ case 0xd0: case 0xd1: case 0xd2: case 0xd3:
+ case 0xd4: case 0xd5: case 0xd6: case 0xd7:
+ return ((tag - BC_INT_SHORT_ZERO) << 16) + 256 * read() + read();
+
+ case 'I':
+ case BC_LONG_INT:
+ return parseInt();
+
+ // direct long
+ case 0xd8: case 0xd9: case 0xda: case 0xdb:
+ case 0xdc: case 0xdd: case 0xde: case 0xdf:
+
+ case 0xe0: case 0xe1: case 0xe2: case 0xe3:
+ case 0xe4: case 0xe5: case 0xe6: case 0xe7:
+ case 0xe8: case 0xe9: case 0xea: case 0xeb:
+ case 0xec: case 0xed: case 0xee: case 0xef:
+ return tag - BC_LONG_ZERO;
+
+ /* byte long */
+ case 0xf0: case 0xf1: case 0xf2: case 0xf3:
+ case 0xf4: case 0xf5: case 0xf6: case 0xf7:
+ case 0xf8: case 0xf9: case 0xfa: case 0xfb:
+ case 0xfc: case 0xfd: case 0xfe: case 0xff:
+ return ((tag - BC_LONG_BYTE_ZERO) << 8) + read();
+
+ /* short long */
+ case 0x38: case 0x39: case 0x3a: case 0x3b:
+ case 0x3c: case 0x3d: case 0x3e: case 0x3f:
+ return ((tag - BC_LONG_SHORT_ZERO) << 16) + 256 * read() + read();
+
+ case 'L':
+ return (double) parseLong();
+
+ case BC_DOUBLE_ZERO:
+ return 0;
+
+ case BC_DOUBLE_ONE:
+ return 1;
+
+ case BC_DOUBLE_BYTE:
+ return (byte) (_offset < _length ? _buffer[_offset++] : read());
+
+ case BC_DOUBLE_SHORT:
+ return (short) (256 * read() + read());
+
+ case BC_DOUBLE_MILL:
+ {
+ int mills = parseInt();
+
+ return 0.001 * mills;
+ }
+
+ case 'D':
+ return parseDouble();
+
+ default:
+ throw expect("double", tag);
+ }
+ }
+
+ /**
+ * Reads a date.
+ *
+ *
+ * T b64 b56 b48 b40 b32 b24 b16 b8
+ *
+ */
+ public long readUTCDate()
+ throws IOException
+ {
+ int tag = read();
+
+ if (tag == BC_DATE) {
+ return parseLong();
+ }
+ else if (tag == BC_DATE_MINUTE) {
+ return parseInt() * 60000L;
+ }
+ else
+ throw expect("date", tag);
+ }
+
+ /**
+ * Reads a byte from the stream.
+ */
+ public int readChar()
+ throws IOException
+ {
+ if (_chunkLength > 0) {
+ _chunkLength--;
+ if (_chunkLength == 0 && _isLastChunk)
+ _chunkLength = END_OF_DATA;
+
+ int ch = parseUTF8Char();
+ return ch;
+ }
+ else if (_chunkLength == END_OF_DATA) {
+ _chunkLength = 0;
+ return -1;
+ }
+
+ int tag = read();
+
+ switch (tag) {
+ case 'N':
+ return -1;
+
+ case 'S':
+ case BC_STRING_CHUNK:
+ _isLastChunk = tag == 'S';
+ _chunkLength = (read() << 8) + read();
+
+ _chunkLength--;
+ int value = parseUTF8Char();
+
+ // special code so successive read byte won't
+ // be read as a single object.
+ if (_chunkLength == 0 && _isLastChunk)
+ _chunkLength = END_OF_DATA;
+
+ return value;
+
+ default:
+ throw expect("char", tag);
+ }
+ }
+
+ /**
+ * Reads a byte array from the stream.
+ */
+ public int readString(char []buffer, int offset, int length)
+ throws IOException
+ {
+ int readLength = 0;
+
+ if (_chunkLength == END_OF_DATA) {
+ _chunkLength = 0;
+ return -1;
+ }
+ else if (_chunkLength == 0) {
+ int tag = read();
+
+ switch (tag) {
+ case 'N':
+ return -1;
+
+ case 'S':
+ case BC_STRING_CHUNK:
+ _isLastChunk = tag == 'S';
+ _chunkLength = (read() << 8) + read();
+ break;
+
+ case 0x00: case 0x01: case 0x02: case 0x03:
+ case 0x04: case 0x05: case 0x06: case 0x07:
+ case 0x08: case 0x09: case 0x0a: case 0x0b:
+ case 0x0c: case 0x0d: case 0x0e: case 0x0f:
+
+ case 0x10: case 0x11: case 0x12: case 0x13:
+ case 0x14: case 0x15: case 0x16: case 0x17:
+ case 0x18: case 0x19: case 0x1a: case 0x1b:
+ case 0x1c: case 0x1d: case 0x1e: case 0x1f:
+ _isLastChunk = true;
+ _chunkLength = tag - 0x00;
+ break;
+
+ case 0x30: case 0x31: case 0x32: case 0x33:
+ _isLastChunk = true;
+ _chunkLength = (tag - 0x30) * 256 + read();
+ break;
+
+ default:
+ throw expect("string", tag);
+ }
+ }
+
+ while (length > 0) {
+ if (_chunkLength > 0) {
+ buffer[offset++] = (char) parseUTF8Char();
+ _chunkLength--;
+ length--;
+ readLength++;
+ }
+ else if (_isLastChunk) {
+ if (readLength == 0)
+ return -1;
+ else {
+ _chunkLength = END_OF_DATA;
+ return readLength;
+ }
+ }
+ else {
+ int tag = read();
+
+ switch (tag) {
+ case 'S':
+ case BC_STRING_CHUNK:
+ _isLastChunk = tag == 'S';
+ _chunkLength = (read() << 8) + read();
+ break;
+
+ case 0x00: case 0x01: case 0x02: case 0x03:
+ case 0x04: case 0x05: case 0x06: case 0x07:
+ case 0x08: case 0x09: case 0x0a: case 0x0b:
+ case 0x0c: case 0x0d: case 0x0e: case 0x0f:
+
+ case 0x10: case 0x11: case 0x12: case 0x13:
+ case 0x14: case 0x15: case 0x16: case 0x17:
+ case 0x18: case 0x19: case 0x1a: case 0x1b:
+ case 0x1c: case 0x1d: case 0x1e: case 0x1f:
+ _isLastChunk = true;
+ _chunkLength = tag - 0x00;
+ break;
+
+ case 0x30: case 0x31: case 0x32: case 0x33:
+ _isLastChunk = true;
+ _chunkLength = (tag - 0x30) * 256 + read();
+ break;
+
+ default:
+ throw expect("string", tag);
+ }
+ }
+ }
+
+ if (readLength == 0)
+ return -1;
+ else if (_chunkLength > 0 || ! _isLastChunk)
+ return readLength;
+ else {
+ _chunkLength = END_OF_DATA;
+ return readLength;
+ }
+ }
+
+ /**
+ * Reads a string
+ *
+ *
+ * S b16 b8 string value
+ *
+ */
+ public String readString()
+ throws IOException
+ {
+ int tag = read();
+
+ switch (tag) {
+ case 'N':
+ return null;
+ case 'T':
+ return "true";
+ case 'F':
+ return "false";
+
+ // direct integer
+ case 0x80: case 0x81: case 0x82: case 0x83:
+ case 0x84: case 0x85: case 0x86: case 0x87:
+ case 0x88: case 0x89: case 0x8a: case 0x8b:
+ case 0x8c: case 0x8d: case 0x8e: case 0x8f:
+
+ case 0x90: case 0x91: case 0x92: case 0x93:
+ case 0x94: case 0x95: case 0x96: case 0x97:
+ case 0x98: case 0x99: case 0x9a: case 0x9b:
+ case 0x9c: case 0x9d: case 0x9e: case 0x9f:
+
+ case 0xa0: case 0xa1: case 0xa2: case 0xa3:
+ case 0xa4: case 0xa5: case 0xa6: case 0xa7:
+ case 0xa8: case 0xa9: case 0xaa: case 0xab:
+ case 0xac: case 0xad: case 0xae: case 0xaf:
+
+ case 0xb0: case 0xb1: case 0xb2: case 0xb3:
+ case 0xb4: case 0xb5: case 0xb6: case 0xb7:
+ case 0xb8: case 0xb9: case 0xba: case 0xbb:
+ case 0xbc: case 0xbd: case 0xbe: case 0xbf:
+ return String.valueOf((tag - 0x90));
+
+ /* byte int */
+ case 0xc0: case 0xc1: case 0xc2: case 0xc3:
+ case 0xc4: case 0xc5: case 0xc6: case 0xc7:
+ case 0xc8: case 0xc9: case 0xca: case 0xcb:
+ case 0xcc: case 0xcd: case 0xce: case 0xcf:
+ return String.valueOf(((tag - BC_INT_BYTE_ZERO) << 8) + read());
+
+ /* short int */
+ case 0xd0: case 0xd1: case 0xd2: case 0xd3:
+ case 0xd4: case 0xd5: case 0xd6: case 0xd7:
+ return String.valueOf(((tag - BC_INT_SHORT_ZERO) << 16)
+ + 256 * read() + read());
+
+ case 'I':
+ case BC_LONG_INT:
+ return String.valueOf(parseInt());
+
+ // direct long
+ case 0xd8: case 0xd9: case 0xda: case 0xdb:
+ case 0xdc: case 0xdd: case 0xde: case 0xdf:
+
+ case 0xe0: case 0xe1: case 0xe2: case 0xe3:
+ case 0xe4: case 0xe5: case 0xe6: case 0xe7:
+ case 0xe8: case 0xe9: case 0xea: case 0xeb:
+ case 0xec: case 0xed: case 0xee: case 0xef:
+ return String.valueOf(tag - BC_LONG_ZERO);
+
+ /* byte long */
+ case 0xf0: case 0xf1: case 0xf2: case 0xf3:
+ case 0xf4: case 0xf5: case 0xf6: case 0xf7:
+ case 0xf8: case 0xf9: case 0xfa: case 0xfb:
+ case 0xfc: case 0xfd: case 0xfe: case 0xff:
+ return String.valueOf(((tag - BC_LONG_BYTE_ZERO) << 8) + read());
+
+ /* short long */
+ case 0x38: case 0x39: case 0x3a: case 0x3b:
+ case 0x3c: case 0x3d: case 0x3e: case 0x3f:
+ return String.valueOf(((tag - BC_LONG_SHORT_ZERO) << 16)
+ + 256 * read() + read());
+
+ case 'L':
+ return String.valueOf(parseLong());
+
+ case BC_DOUBLE_ZERO:
+ return "0.0";
+
+ case BC_DOUBLE_ONE:
+ return "1.0";
+
+ case BC_DOUBLE_BYTE:
+ return String.valueOf((byte) (_offset < _length
+ ? _buffer[_offset++]
+ : read()));
+
+ case BC_DOUBLE_SHORT:
+ return String.valueOf(((short) (256 * read() + read())));
+
+ case BC_DOUBLE_MILL:
+ {
+ int mills = parseInt();
+
+ return String.valueOf(0.001 * mills);
+ }
+
+ case 'D':
+ return String.valueOf(parseDouble());
+
+ case 'S':
+ case BC_STRING_CHUNK:
+ _isLastChunk = tag == 'S';
+ _chunkLength = (read() << 8) + read();
+
+ _sbuf.setLength(0);
+ int ch;
+
+ while ((ch = parseChar()) >= 0)
+ _sbuf.append((char) ch);
+
+ return _sbuf.toString();
+
+ // 0-byte string
+ case 0x00: case 0x01: case 0x02: case 0x03:
+ case 0x04: case 0x05: case 0x06: case 0x07:
+ case 0x08: case 0x09: case 0x0a: case 0x0b:
+ case 0x0c: case 0x0d: case 0x0e: case 0x0f:
+
+ case 0x10: case 0x11: case 0x12: case 0x13:
+ case 0x14: case 0x15: case 0x16: case 0x17:
+ case 0x18: case 0x19: case 0x1a: case 0x1b:
+ case 0x1c: case 0x1d: case 0x1e: case 0x1f:
+ _isLastChunk = true;
+ _chunkLength = tag - 0x00;
+
+ _sbuf.setLength(0);
+
+ while ((ch = parseChar()) >= 0) {
+ _sbuf.append((char) ch);
+ }
+
+ return _sbuf.toString();
+
+ case 0x30: case 0x31: case 0x32: case 0x33:
+ _isLastChunk = true;
+ _chunkLength = (tag - 0x30) * 256 + read();
+
+ _sbuf.setLength(0);
+
+ while ((ch = parseChar()) >= 0)
+ _sbuf.append((char) ch);
+
+ return _sbuf.toString();
+
+ default:
+ throw expect("string", tag);
+ }
+ }
+
+ /**
+ * Reads a byte array
+ *
+ *
+ * B b16 b8 data value
+ *
+ */
+ public byte []readBytes()
+ throws IOException
+ {
+ int tag = read();
+
+ switch (tag) {
+ case 'N':
+ return null;
+
+ case BC_BINARY:
+ case BC_BINARY_CHUNK:
+ _isLastChunk = tag == BC_BINARY;
+ _chunkLength = (read() << 8) + read();
+
+ ByteArrayOutputStream bos = new ByteArrayOutputStream();
+
+ int data;
+ while ((data = parseByte()) >= 0)
+ bos.write(data);
+
+ return bos.toByteArray();
+
+ case 0x20: case 0x21: case 0x22: case 0x23:
+ case 0x24: case 0x25: case 0x26: case 0x27:
+ case 0x28: case 0x29: case 0x2a: case 0x2b:
+ case 0x2c: case 0x2d: case 0x2e: case 0x2f:
+ {
+ _isLastChunk = true;
+ _chunkLength = tag - 0x20;
+
+ byte []buffer = new byte[_chunkLength];
+
+ int offset = 0;
+ while (offset < _chunkLength) {
+ int sublen = read(buffer, 0, _chunkLength - offset);
+
+ if (sublen <= 0)
+ break;
+
+ offset += sublen;
+ }
+
+ return buffer;
+ }
+
+ case 0x34: case 0x35: case 0x36: case 0x37:
+ {
+ _isLastChunk = true;
+ _chunkLength = (tag - 0x34) * 256 + read();
+
+ byte []buffer = new byte[_chunkLength];
+
+ int offset = 0;
+ while (offset < _chunkLength) {
+ int sublen = read(buffer, 0, _chunkLength - offset);
+
+ if (sublen <= 0)
+ break;
+
+ offset += sublen;
+ }
+
+ return buffer;
+ }
+
+ default:
+ throw expect("bytes", tag);
+ }
+ }
+
+ /**
+ * Reads a byte from the stream.
+ */
+ public int readByte()
+ throws IOException
+ {
+ if (_chunkLength > 0) {
+ _chunkLength--;
+ if (_chunkLength == 0 && _isLastChunk)
+ _chunkLength = END_OF_DATA;
+
+ return read();
+ }
+ else if (_chunkLength == END_OF_DATA) {
+ _chunkLength = 0;
+ return -1;
+ }
+
+ int tag = read();
+
+ switch (tag) {
+ case 'N':
+ return -1;
+
+ case 'B':
+ case BC_BINARY_CHUNK:
+ {
+ _isLastChunk = tag == 'B';
+ _chunkLength = (read() << 8) + read();
+
+ int value = parseByte();
+
+ // special code so successive read byte won't
+ // be read as a single object.
+ if (_chunkLength == 0 && _isLastChunk)
+ _chunkLength = END_OF_DATA;
+
+ return value;
+ }
+
+ case 0x20: case 0x21: case 0x22: case 0x23:
+ case 0x24: case 0x25: case 0x26: case 0x27:
+ case 0x28: case 0x29: case 0x2a: case 0x2b:
+ case 0x2c: case 0x2d: case 0x2e: case 0x2f:
+ {
+ _isLastChunk = true;
+ _chunkLength = tag - 0x20;
+
+ int value = parseByte();
+
+ // special code so successive read byte won't
+ // be read as a single object.
+ if (_chunkLength == 0)
+ _chunkLength = END_OF_DATA;
+
+ return value;
+ }
+
+ case 0x34: case 0x35: case 0x36: case 0x37:
+ {
+ _isLastChunk = true;
+ _chunkLength = (tag - 0x34) * 256 + read();
+
+ int value = parseByte();
+
+ // special code so successive read byte won't
+ // be read as a single object.
+ if (_chunkLength == 0)
+ _chunkLength = END_OF_DATA;
+
+ return value;
+ }
+
+ default:
+ throw expect("binary", tag);
+ }
+ }
+
+ /**
+ * Reads a byte array from the stream.
+ */
+ public int readBytes(byte []buffer, int offset, int length)
+ throws IOException
+ {
+ int readLength = 0;
+
+ if (_chunkLength == END_OF_DATA) {
+ _chunkLength = 0;
+ return -1;
+ }
+ else if (_chunkLength == 0) {
+ int tag = read();
+
+ switch (tag) {
+ case 'N':
+ return -1;
+
+ case 'B':
+ case BC_BINARY_CHUNK:
+ _isLastChunk = tag == 'B';
+ _chunkLength = (read() << 8) + read();
+ break;
+
+ case 0x20: case 0x21: case 0x22: case 0x23:
+ case 0x24: case 0x25: case 0x26: case 0x27:
+ case 0x28: case 0x29: case 0x2a: case 0x2b:
+ case 0x2c: case 0x2d: case 0x2e: case 0x2f:
+ {
+ _isLastChunk = true;
+ _chunkLength = tag - 0x20;
+ break;
+ }
+
+ case 0x34: case 0x35: case 0x36: case 0x37:
+ {
+ _isLastChunk = true;
+ _chunkLength = (tag - 0x34) * 256 + read();
+ break;
+ }
+
+ default:
+ throw expect("binary", tag);
+ }
+ }
+
+ while (length > 0) {
+ if (_chunkLength > 0) {
+ buffer[offset++] = (byte) read();
+ _chunkLength--;
+ length--;
+ readLength++;
+ }
+ else if (_isLastChunk) {
+ if (readLength == 0)
+ return -1;
+ else {
+ _chunkLength = END_OF_DATA;
+ return readLength;
+ }
+ }
+ else {
+ int tag = read();
+
+ switch (tag) {
+ case 'B':
+ case BC_BINARY_CHUNK:
+ _isLastChunk = tag == 'B';
+ _chunkLength = (read() << 8) + read();
+ break;
+
+ default:
+ throw expect("binary", tag);
+ }
+ }
+ }
+
+ if (readLength == 0)
+ return -1;
+ else if (_chunkLength > 0 || ! _isLastChunk)
+ return readLength;
+ else {
+ _chunkLength = END_OF_DATA;
+ return readLength;
+ }
+ }
+
+ /**
+ * Reads a fault.
+ */
+ private HashMap readFault()
+ throws IOException
+ {
+ HashMap map = new HashMap();
+
+ int code = read();
+ for (; code > 0 && code != 'Z'; code = read()) {
+ _offset--;
+
+ Object key = readObject();
+ Object value = readObject();
+
+ if (key != null && value != null)
+ map.put(key, value);
+ }
+
+ if (code != 'Z')
+ throw expect("fault", code);
+
+ return map;
+ }
+
+ /**
+ * Reads an object from the input stream with an expected type.
+ */
+ public Object readObject(Class cl)
+ throws IOException
+ {
+ if (cl == null || cl == Object.class)
+ return readObject();
+
+ int tag = _offset < _length ? (_buffer[_offset++] & 0xff) : read();
+
+ switch (tag) {
+ case 'N':
+ return null;
+
+ case 'H':
+ {
+ Deserializer reader = findSerializerFactory().getDeserializer(cl);
+
+ return reader.readMap(this);
+ }
+
+ case 'M':
+ {
+ String type = readType();
+
+ // hessian/3bb3
+ if ("".equals(type)) {
+ Deserializer reader;
+ reader = findSerializerFactory().getDeserializer(cl);
+
+ return reader.readMap(this);
+ }
+ else {
+ Deserializer reader;
+ reader = findSerializerFactory().getObjectDeserializer(type, cl);
+
+ return reader.readMap(this);
+ }
+ }
+
+ case 'C':
+ {
+ readObjectDefinition(cl);
+
+ return readObject(cl);
+ }
+
+ case 0x60: case 0x61: case 0x62: case 0x63:
+ case 0x64: case 0x65: case 0x66: case 0x67:
+ case 0x68: case 0x69: case 0x6a: case 0x6b:
+ case 0x6c: case 0x6d: case 0x6e: case 0x6f:
+ {
+ int ref = tag - 0x60;
+ int size = _classDefs.size();
+
+ if (ref < 0 || size <= ref)
+ throw new HessianProtocolException("'" + ref + "' is an unknown class definition");
+
+ ObjectDefinition def = _classDefs.get(ref);
+
+ return readObjectInstance(cl, def);
+ }
+
+ case 'O':
+ {
+ int ref = readInt();
+ int size = _classDefs.size();
+
+ if (ref < 0 || size <= ref)
+ throw new HessianProtocolException("'" + ref + "' is an unknown class definition");
+
+ ObjectDefinition def = _classDefs.get(ref);
+
+ return readObjectInstance(cl, def);
+ }
+
+ case BC_LIST_VARIABLE:
+ {
+ String type = readType();
+
+ Deserializer reader;
+ reader = findSerializerFactory().getListDeserializer(type, cl);
+
+ Object v = reader.readList(this, -1);
+
+ return v;
+ }
+
+ case BC_LIST_FIXED:
+ {
+ String type = readType();
+ int length = readInt();
+
+ Deserializer reader;
+ reader = findSerializerFactory().getListDeserializer(type, cl);
+
+ Object v = reader.readLengthList(this, length);
+
+ return v;
+ }
+
+ case 0x70: case 0x71: case 0x72: case 0x73:
+ case 0x74: case 0x75: case 0x76: case 0x77:
+ {
+ int length = tag - 0x70;
+
+ String type = readType();
+
+ Deserializer reader;
+ reader = findSerializerFactory().getListDeserializer(type, cl);
+
+ Object v = reader.readLengthList(this, length);
+
+ return v;
+ }
+
+ case BC_LIST_VARIABLE_UNTYPED:
+ {
+ Deserializer reader;
+ reader = findSerializerFactory().getListDeserializer(null, cl);
+
+ Object v = reader.readList(this, -1);
+
+ return v;
+ }
+
+ case BC_LIST_FIXED_UNTYPED:
+ {
+ int length = readInt();
+
+ Deserializer reader;
+ reader = findSerializerFactory().getListDeserializer(null, cl);
+
+ Object v = reader.readLengthList(this, length);
+
+ return v;
+ }
+
+ case 0x78: case 0x79: case 0x7a: case 0x7b:
+ case 0x7c: case 0x7d: case 0x7e: case 0x7f:
+ {
+ int length = tag - 0x78;
+
+ Deserializer reader;
+ reader = findSerializerFactory().getListDeserializer(null, cl);
+
+ Object v = reader.readLengthList(this, length);
+
+ return v;
+ }
+
+ case BC_REF:
+ {
+ int ref = readInt();
+
+ return _refs.get(ref);
+ }
+ }
+
+ if (tag >= 0)
+ _offset--;
+
+ // hessian/3b2i vs hessian/3406
+ // return readObject();
+ Object value = findSerializerFactory().getDeserializer(cl).readObject(this);
+ return value;
+ }
+
+ /**
+ * Reads an arbitrary object from the input stream when the type
+ * is unknown.
+ */
+ public Object readObject()
+ throws IOException
+ {
+ int tag = _offset < _length ? (_buffer[_offset++] & 0xff) : read();
+
+ switch (tag) {
+ case 'N':
+ return null;
+
+ case 'T':
+ return Boolean.valueOf(true);
+
+ case 'F':
+ return Boolean.valueOf(false);
+
+ // direct integer
+ case 0x80: case 0x81: case 0x82: case 0x83:
+ case 0x84: case 0x85: case 0x86: case 0x87:
+ case 0x88: case 0x89: case 0x8a: case 0x8b:
+ case 0x8c: case 0x8d: case 0x8e: case 0x8f:
+
+ case 0x90: case 0x91: case 0x92: case 0x93:
+ case 0x94: case 0x95: case 0x96: case 0x97:
+ case 0x98: case 0x99: case 0x9a: case 0x9b:
+ case 0x9c: case 0x9d: case 0x9e: case 0x9f:
+
+ case 0xa0: case 0xa1: case 0xa2: case 0xa3:
+ case 0xa4: case 0xa5: case 0xa6: case 0xa7:
+ case 0xa8: case 0xa9: case 0xaa: case 0xab:
+ case 0xac: case 0xad: case 0xae: case 0xaf:
+
+ case 0xb0: case 0xb1: case 0xb2: case 0xb3:
+ case 0xb4: case 0xb5: case 0xb6: case 0xb7:
+ case 0xb8: case 0xb9: case 0xba: case 0xbb:
+ case 0xbc: case 0xbd: case 0xbe: case 0xbf:
+ return Integer.valueOf(tag - BC_INT_ZERO);
+
+ /* byte int */
+ case 0xc0: case 0xc1: case 0xc2: case 0xc3:
+ case 0xc4: case 0xc5: case 0xc6: case 0xc7:
+ case 0xc8: case 0xc9: case 0xca: case 0xcb:
+ case 0xcc: case 0xcd: case 0xce: case 0xcf:
+ return Integer.valueOf(((tag - BC_INT_BYTE_ZERO) << 8) + read());
+
+ /* short int */
+ case 0xd0: case 0xd1: case 0xd2: case 0xd3:
+ case 0xd4: case 0xd5: case 0xd6: case 0xd7:
+ return Integer.valueOf(((tag - BC_INT_SHORT_ZERO) << 16)
+ + 256 * read() + read());
+
+ case 'I':
+ return Integer.valueOf(parseInt());
+
+ // direct long
+ case 0xd8: case 0xd9: case 0xda: case 0xdb:
+ case 0xdc: case 0xdd: case 0xde: case 0xdf:
+
+ case 0xe0: case 0xe1: case 0xe2: case 0xe3:
+ case 0xe4: case 0xe5: case 0xe6: case 0xe7:
+ case 0xe8: case 0xe9: case 0xea: case 0xeb:
+ case 0xec: case 0xed: case 0xee: case 0xef:
+ return Long.valueOf(tag - BC_LONG_ZERO);
+
+ /* byte long */
+ case 0xf0: case 0xf1: case 0xf2: case 0xf3:
+ case 0xf4: case 0xf5: case 0xf6: case 0xf7:
+ case 0xf8: case 0xf9: case 0xfa: case 0xfb:
+ case 0xfc: case 0xfd: case 0xfe: case 0xff:
+ return Long.valueOf(((tag - BC_LONG_BYTE_ZERO) << 8) + read());
+
+ /* short long */
+ case 0x38: case 0x39: case 0x3a: case 0x3b:
+ case 0x3c: case 0x3d: case 0x3e: case 0x3f:
+ return Long.valueOf(((tag - BC_LONG_SHORT_ZERO) << 16) + 256 * read() + read());
+
+ case BC_LONG_INT:
+ return Long.valueOf(parseInt());
+
+ case 'L':
+ return Long.valueOf(parseLong());
+
+ case BC_DOUBLE_ZERO:
+ return Double.valueOf(0);
+
+ case BC_DOUBLE_ONE:
+ return Double.valueOf(1);
+
+ case BC_DOUBLE_BYTE:
+ return Double.valueOf((byte) read());
+
+ case BC_DOUBLE_SHORT:
+ return Double.valueOf((short) (256 * read() + read()));
+
+ case BC_DOUBLE_MILL:
+ {
+ int mills = parseInt();
+
+ return Double.valueOf(0.001 * mills);
+ }
+
+ case 'D':
+ return Double.valueOf(parseDouble());
+
+ case BC_DATE:
+ return new Date(parseLong());
+
+ case BC_DATE_MINUTE:
+ return new Date(parseInt() * 60000L);
+
+ case BC_STRING_CHUNK:
+ case 'S':
+ {
+ _isLastChunk = tag == 'S';
+ _chunkLength = (read() << 8) + read();
+
+ int data;
+ _sbuf.setLength(0);
+
+ while ((data = parseChar()) >= 0)
+ _sbuf.append((char) data);
+
+ return _sbuf.toString();
+ }
+
+ case 0x00: case 0x01: case 0x02: case 0x03:
+ case 0x04: case 0x05: case 0x06: case 0x07:
+ case 0x08: case 0x09: case 0x0a: case 0x0b:
+ case 0x0c: case 0x0d: case 0x0e: case 0x0f:
+
+ case 0x10: case 0x11: case 0x12: case 0x13:
+ case 0x14: case 0x15: case 0x16: case 0x17:
+ case 0x18: case 0x19: case 0x1a: case 0x1b:
+ case 0x1c: case 0x1d: case 0x1e: case 0x1f:
+ {
+ _isLastChunk = true;
+ _chunkLength = tag - 0x00;
+
+ int data;
+ _sbuf.setLength(0);
+
+ while ((data = parseChar()) >= 0)
+ _sbuf.append((char) data);
+
+ return _sbuf.toString();
+ }
+
+ case 0x30: case 0x31: case 0x32: case 0x33:
+ {
+ _isLastChunk = true;
+ _chunkLength = (tag - 0x30) * 256 + read();
+
+ _sbuf.setLength(0);
+
+ int ch;
+ while ((ch = parseChar()) >= 0)
+ _sbuf.append((char) ch);
+
+ return _sbuf.toString();
+ }
+
+ case BC_BINARY_CHUNK:
+ case 'B':
+ {
+ _isLastChunk = tag == 'B';
+ _chunkLength = (read() << 8) + read();
+
+ int data;
+ ByteArrayOutputStream bos = new ByteArrayOutputStream();
+
+ while ((data = parseByte()) >= 0)
+ bos.write(data);
+
+ return bos.toByteArray();
+ }
+
+ case 0x20: case 0x21: case 0x22: case 0x23:
+ case 0x24: case 0x25: case 0x26: case 0x27:
+ case 0x28: case 0x29: case 0x2a: case 0x2b:
+ case 0x2c: case 0x2d: case 0x2e: case 0x2f:
+ {
+ _isLastChunk = true;
+ int len = tag - 0x20;
+ _chunkLength = 0;
+
+ byte []data = new byte[len];
+
+ for (int i = 0; i < len; i++)
+ data[i] = (byte) read();
+
+ return data;
+ }
+
+ case 0x34: case 0x35: case 0x36: case 0x37:
+ {
+ _isLastChunk = true;
+ int len = (tag - 0x34) * 256 + read();
+ _chunkLength = 0;
+
+ byte []buffer = new byte[len];
+
+ for (int i = 0; i < len; i++) {
+ buffer[i] = (byte) read();
+ }
+
+ return buffer;
+ }
+
+ case BC_LIST_VARIABLE:
+ {
+ // variable length list
+ String type = readType();
+
+ return findSerializerFactory().readList(this, -1, type);
+ }
+
+ case BC_LIST_VARIABLE_UNTYPED:
+ {
+ return findSerializerFactory().readList(this, -1, null);
+ }
+
+ case BC_LIST_FIXED:
+ {
+ // fixed length lists
+ String type = readType();
+ int length = readInt();
+
+ Deserializer reader;
+ reader = findSerializerFactory().getListDeserializer(type, null);
+
+ return reader.readLengthList(this, length);
+ }
+
+ case BC_LIST_FIXED_UNTYPED:
+ {
+ // fixed length lists
+ int length = readInt();
+
+ Deserializer reader;
+ reader = findSerializerFactory().getListDeserializer(null, null);
+
+ return reader.readLengthList(this, length);
+ }
+
+ // compact fixed list
+ case 0x70: case 0x71: case 0x72: case 0x73:
+ case 0x74: case 0x75: case 0x76: case 0x77:
+ {
+ // fixed length lists
+ String type = readType();
+ int length = tag - 0x70;
+
+ Deserializer reader;
+ reader = findSerializerFactory().getListDeserializer(type, null);
+
+ return reader.readLengthList(this, length);
+ }
+
+ // compact fixed untyped list
+ case 0x78: case 0x79: case 0x7a: case 0x7b:
+ case 0x7c: case 0x7d: case 0x7e: case 0x7f:
+ {
+ // fixed length lists
+ int length = tag - 0x78;
+
+ Deserializer reader;
+ reader = findSerializerFactory().getListDeserializer(null, null);
+
+ return reader.readLengthList(this, length);
+ }
+
+ case 'H':
+ {
+ return findSerializerFactory().readMap(this, null);
+ }
+
+ case 'M':
+ {
+ String type = readType();
+
+ return findSerializerFactory().readMap(this, type);
+ }
+
+ case 'C':
+ {
+ readObjectDefinition(null);
+
+ return readObject();
+ }
+
+ case 0x60: case 0x61: case 0x62: case 0x63:
+ case 0x64: case 0x65: case 0x66: case 0x67:
+ case 0x68: case 0x69: case 0x6a: case 0x6b:
+ case 0x6c: case 0x6d: case 0x6e: case 0x6f:
+ {
+ int ref = tag - 0x60;
+
+ if (_classDefs.size() <= ref)
+ throw error("No classes defined at reference '"
+ + Integer.toHexString(tag) + "'");
+
+ ObjectDefinition def = _classDefs.get(ref);
+
+ return readObjectInstance(null, def);
+ }
+
+ case 'O':
+ {
+ int ref = readInt();
+
+ if (_classDefs.size() <= ref)
+ throw error("Illegal object reference #" + ref);
+
+ ObjectDefinition def = _classDefs.get(ref);
+
+ return readObjectInstance(null, def);
+ }
+
+ case BC_REF:
+ {
+ int ref = readInt();
+
+ return _refs.get(ref);
+ }
+
+ default:
+ if (tag < 0)
+ throw new EOFException("readObject: unexpected end of file");
+ else
+ throw error("readObject: unknown code " + codeName(tag));
+ }
+ }
+
+ /**
+ * Reads an object definition:
+ *
+ *
+ * O string (string)* *
+ *
+ */
+ private void readObjectDefinition(Class cl)
+ throws IOException
+ {
+ String type = readString();
+ int len = readInt();
+
+ SerializerFactory factory = findSerializerFactory();
+
+ Deserializer reader = factory.getObjectDeserializer(type, null);
+
+ Object []fields = reader.createFields(len);
+ String []fieldNames = new String[len];
+
+ for (int i = 0; i < len; i++) {
+ String name = readString();
+
+ fields[i] = reader.createField(name);
+ fieldNames[i] = name;
+ }
+
+ ObjectDefinition def
+ = new ObjectDefinition(type, reader, fields, fieldNames);
+
+ _classDefs.add(def);
+ }
+
+ private Object readObjectInstance(Class cl,
+ ObjectDefinition def)
+ throws IOException
+ {
+ String type = def.getType();
+ Deserializer reader = def.getReader();
+ Object []fields = def.getFields();
+
+ SerializerFactory factory = findSerializerFactory();
+
+ if (cl != reader.getType() && cl != null) {
+ reader = factory.getObjectDeserializer(type, cl);
+
+ return reader.readObject(this, def.getFieldNames());
+ }
+ else {
+ return reader.readObject(this, fields);
+ }
+ }
+
+ /**
+ * Reads a remote object.
+ */
+ public Object readRemote()
+ throws IOException
+ {
+ String type = readType();
+ String url = readString();
+
+ return resolveRemote(type, url);
+ }
+
+ /**
+ * Reads a reference.
+ */
+ public Object readRef()
+ throws IOException
+ {
+ return _refs.get(parseInt());
+ }
+
+ /**
+ * Reads the start of a list.
+ */
+ public int readListStart()
+ throws IOException
+ {
+ return read();
+ }
+
+ /**
+ * Reads the start of a list.
+ */
+ public int readMapStart()
+ throws IOException
+ {
+ return read();
+ }
+
+ /**
+ * Returns true if this is the end of a list or a map.
+ */
+ public boolean isEnd()
+ throws IOException
+ {
+ int code;
+
+ if (_offset < _length)
+ code = (_buffer[_offset] & 0xff);
+ else {
+ code = read();
+
+ if (code >= 0)
+ _offset--;
+ }
+
+ return (code < 0 || code == 'Z');
+ }
+
+ /**
+ * Reads the end byte.
+ */
+ public void readEnd()
+ throws IOException
+ {
+ int code = _offset < _length ? (_buffer[_offset++] & 0xff) : read();
+
+ if (code == 'Z')
+ return;
+ else if (code < 0)
+ throw error("unexpected end of file");
+ else
+ throw error("unknown code:" + codeName(code));
+ }
+
+ /**
+ * Reads the end byte.
+ */
+ public void readMapEnd()
+ throws IOException
+ {
+ int code = _offset < _length ? (_buffer[_offset++] & 0xff) : read();
+
+ if (code != 'Z')
+ throw error("expected end of map ('Z') at '" + codeName(code) + "'");
+ }
+
+ /**
+ * Reads the end byte.
+ */
+ public void readListEnd()
+ throws IOException
+ {
+ int code = _offset < _length ? (_buffer[_offset++] & 0xff) : read();
+
+ if (code != 'Z')
+ throw error("expected end of list ('Z') at '" + codeName(code) + "'");
+ }
+
+ /**
+ * Adds a list/map reference.
+ */
+ public int addRef(Object ref)
+ {
+ if (_refs == null)
+ _refs = new ArrayList();
+
+ _refs.add(ref);
+
+ return _refs.size() - 1;
+ }
+
+ /**
+ * Adds a list/map reference.
+ */
+ public void setRef(int i, Object ref)
+ {
+ _refs.set(i, ref);
+ }
+
+ /**
+ * Resets the references for streaming.
+ */
+ public void resetReferences()
+ {
+ _refs.clear();
+ }
+
+ public void reset()
+ {
+ resetReferences();
+
+ _classDefs.clear();
+ _types.clear();
+ }
+
+ public void resetBuffer()
+ {
+ int offset = _offset;
+ _offset = 0;
+
+ int length = _length;
+ _length = 0;
+
+ if (length > 0 && offset != length)
+ throw new IllegalStateException("offset=" + offset + " length=" + length);
+ }
+
+ public Object readStreamingObject()
+ throws IOException
+ {
+ if (_refs != null)
+ _refs.clear();
+
+ return readObject();
+ }
+
+ /**
+ * Resolves a remote object.
+ */
+ public Object resolveRemote(String type, String url)
+ throws IOException
+ {
+ HessianRemoteResolver resolver = getRemoteResolver();
+
+ if (resolver != null)
+ return resolver.lookup(type, url);
+ else
+ return new HessianRemote(type, url);
+ }
+
+ /**
+ * Parses a type from the stream.
+ *
+ *
+ * type ::= string
+ * type ::= int
+ *
+ */
+ public String readType()
+ throws IOException
+ {
+ int code = _offset < _length ? (_buffer[_offset++] & 0xff) : read();
+ _offset--;
+
+ switch (code) {
+ case 0x00: case 0x01: case 0x02: case 0x03:
+ case 0x04: case 0x05: case 0x06: case 0x07:
+ case 0x08: case 0x09: case 0x0a: case 0x0b:
+ case 0x0c: case 0x0d: case 0x0e: case 0x0f:
+
+ case 0x10: case 0x11: case 0x12: case 0x13:
+ case 0x14: case 0x15: case 0x16: case 0x17:
+ case 0x18: case 0x19: case 0x1a: case 0x1b:
+ case 0x1c: case 0x1d: case 0x1e: case 0x1f:
+
+ case 0x30: case 0x31: case 0x32: case 0x33:
+ case BC_STRING_CHUNK: case 'S':
+ {
+ String type = readString();
+
+ if (_types == null)
+ _types = new ArrayList();
+
+ _types.add(type);
+
+ return type;
+ }
+
+ default:
+ {
+ int ref = readInt();
+
+ if (_types.size() <= ref)
+ throw new IndexOutOfBoundsException("type ref #" + ref + " is greater than the number of valid types (" + _types.size() + ")");
+
+ return (String) _types.get(ref);
+ }
+ }
+ }
+
+ /**
+ * Parses the length for an array
+ *
+ *
+ * l b32 b24 b16 b8
+ *
+ */
+ public int readLength()
+ throws IOException
+ {
+ throw new UnsupportedOperationException();
+ }
+
+ /**
+ * Parses a 32-bit integer value from the stream.
+ *
+ *
+ * b32 b24 b16 b8
+ *
+ */
+ private int parseInt()
+ throws IOException
+ {
+ int offset = _offset;
+
+ if (offset + 3 < _length) {
+ byte []buffer = _buffer;
+
+ int b32 = buffer[offset + 0] & 0xff;
+ int b24 = buffer[offset + 1] & 0xff;
+ int b16 = buffer[offset + 2] & 0xff;
+ int b8 = buffer[offset + 3] & 0xff;
+
+ _offset = offset + 4;
+
+ return (b32 << 24) + (b24 << 16) + (b16 << 8) + b8;
+ }
+ else {
+ int b32 = read();
+ int b24 = read();
+ int b16 = read();
+ int b8 = read();
+
+ return (b32 << 24) + (b24 << 16) + (b16 << 8) + b8;
+ }
+ }
+
+ /**
+ * Parses a 64-bit long value from the stream.
+ *
+ *
+ * b64 b56 b48 b40 b32 b24 b16 b8
+ *
+ */
+ private long parseLong()
+ throws IOException
+ {
+ long b64 = read();
+ long b56 = read();
+ long b48 = read();
+ long b40 = read();
+ long b32 = read();
+ long b24 = read();
+ long b16 = read();
+ long b8 = read();
+
+ return ((b64 << 56)
+ + (b56 << 48)
+ + (b48 << 40)
+ + (b40 << 32)
+ + (b32 << 24)
+ + (b24 << 16)
+ + (b16 << 8)
+ + b8);
+ }
+
+ /**
+ * Parses a 64-bit double value from the stream.
+ *
+ *
+ * b64 b56 b48 b40 b32 b24 b16 b8
+ *
+ */
+ private double parseDouble()
+ throws IOException
+ {
+ long bits = parseLong();
+
+ return Double.longBitsToDouble(bits);
+ }
+
+ org.w3c.dom.Node parseXML()
+ throws IOException
+ {
+ throw new UnsupportedOperationException();
+ }
+
+ /**
+ * Reads a character from the underlying stream.
+ */
+ private int parseChar()
+ throws IOException
+ {
+ while (_chunkLength <= 0) {
+ if (_isLastChunk)
+ return -1;
+
+ int code = _offset < _length ? (_buffer[_offset++] & 0xff) : read();
+
+ switch (code) {
+ case BC_STRING_CHUNK:
+ _isLastChunk = false;
+
+ _chunkLength = (read() << 8) + read();
+ break;
+
+ case 'S':
+ _isLastChunk = true;
+
+ _chunkLength = (read() << 8) + read();
+ break;
+
+ case 0x00: case 0x01: case 0x02: case 0x03:
+ case 0x04: case 0x05: case 0x06: case 0x07:
+ case 0x08: case 0x09: case 0x0a: case 0x0b:
+ case 0x0c: case 0x0d: case 0x0e: case 0x0f:
+
+ case 0x10: case 0x11: case 0x12: case 0x13:
+ case 0x14: case 0x15: case 0x16: case 0x17:
+ case 0x18: case 0x19: case 0x1a: case 0x1b:
+ case 0x1c: case 0x1d: case 0x1e: case 0x1f:
+ _isLastChunk = true;
+ _chunkLength = code - 0x00;
+ break;
+
+ case 0x30: case 0x31: case 0x32: case 0x33:
+ _isLastChunk = true;
+ _chunkLength = (code - 0x30) * 256 + read();
+ break;
+
+ default:
+ throw expect("string", code);
+ }
+
+ }
+
+ _chunkLength--;
+
+ return parseUTF8Char();
+ }
+
+ /**
+ * Parses a single UTF8 character.
+ */
+ private int parseUTF8Char()
+ throws IOException
+ {
+ int ch = _offset < _length ? (_buffer[_offset++] & 0xff) : read();
+
+ if (ch < 0x80)
+ return ch;
+ else if ((ch & 0xe0) == 0xc0) {
+ int ch1 = read();
+ int v = ((ch & 0x1f) << 6) + (ch1 & 0x3f);
+
+ return v;
+ }
+ else if ((ch & 0xf0) == 0xe0) {
+ int ch1 = read();
+ int ch2 = read();
+ int v = ((ch & 0x0f) << 12) + ((ch1 & 0x3f) << 6) + (ch2 & 0x3f);
+
+ return v;
+ }
+ else
+ throw error("bad utf-8 encoding at " + codeName(ch));
+ }
+
+ /**
+ * Reads a byte from the underlying stream.
+ */
+ private int parseByte()
+ throws IOException
+ {
+ while (_chunkLength <= 0) {
+ if (_isLastChunk) {
+ return -1;
+ }
+
+ int code = read();
+
+ switch (code) {
+ case BC_BINARY_CHUNK:
+ _isLastChunk = false;
+
+ _chunkLength = (read() << 8) + read();
+ break;
+
+ case 'B':
+ _isLastChunk = true;
+
+ _chunkLength = (read() << 8) + read();
+ break;
+
+ case 0x20: case 0x21: case 0x22: case 0x23:
+ case 0x24: case 0x25: case 0x26: case 0x27:
+ case 0x28: case 0x29: case 0x2a: case 0x2b:
+ case 0x2c: case 0x2d: case 0x2e: case 0x2f:
+ _isLastChunk = true;
+
+ _chunkLength = code - 0x20;
+ break;
+
+ case 0x34: case 0x35: case 0x36: case 0x37:
+ _isLastChunk = true;
+ _chunkLength = (code - 0x34) * 256 + read();
+ break;
+
+ default:
+ throw expect("byte[]", code);
+ }
+ }
+
+ _chunkLength--;
+
+ return read();
+ }
+
+ /**
+ * Reads bytes based on an input stream.
+ */
+ public InputStream readInputStream()
+ throws IOException
+ {
+ int tag = read();
+
+ switch (tag) {
+ case 'N':
+ return null;
+
+ case BC_BINARY:
+ case BC_BINARY_CHUNK:
+ _isLastChunk = tag == BC_BINARY;
+ _chunkLength = (read() << 8) + read();
+ break;
+
+ case 0x20: case 0x21: case 0x22: case 0x23:
+ case 0x24: case 0x25: case 0x26: case 0x27:
+ case 0x28: case 0x29: case 0x2a: case 0x2b:
+ case 0x2c: case 0x2d: case 0x2e: case 0x2f:
+ _isLastChunk = true;
+ _chunkLength = tag - 0x20;
+ break;
+
+ case 0x34: case 0x35: case 0x36: case 0x37:
+ _isLastChunk = true;
+ _chunkLength = (tag - 0x34) * 256 + read();
+ break;
+
+ default:
+ throw expect("binary", tag);
+ }
+
+ return new ReadInputStream();
+ }
+
+ /**
+ * Reads bytes from the underlying stream.
+ */
+ int read(byte []buffer, int offset, int length)
+ throws IOException
+ {
+ int readLength = 0;
+
+ while (length > 0) {
+ while (_chunkLength <= 0) {
+ if (_isLastChunk)
+ return readLength == 0 ? -1 : readLength;
+
+ int code = read();
+
+ switch (code) {
+ case BC_BINARY_CHUNK:
+ _isLastChunk = false;
+
+ _chunkLength = (read() << 8) + read();
+ break;
+
+ case BC_BINARY:
+ _isLastChunk = true;
+
+ _chunkLength = (read() << 8) + read();
+ break;
+
+ case 0x20: case 0x21: case 0x22: case 0x23:
+ case 0x24: case 0x25: case 0x26: case 0x27:
+ case 0x28: case 0x29: case 0x2a: case 0x2b:
+ case 0x2c: case 0x2d: case 0x2e: case 0x2f:
+ _isLastChunk = true;
+ _chunkLength = code - 0x20;
+ break;
+
+ case 0x34: case 0x35: case 0x36: case 0x37:
+ _isLastChunk = true;
+ _chunkLength = (code - 0x34) * 256 + read();
+ break;
+
+ default:
+ throw expect("byte[]", code);
+ }
+ }
+
+ int sublen = _chunkLength;
+ if (length < sublen)
+ sublen = length;
+
+ if (_length <= _offset && ! readBuffer())
+ return -1;
+
+ if (_length - _offset < sublen)
+ sublen = _length - _offset;
+
+ System.arraycopy(_buffer, _offset, buffer, offset, sublen);
+
+ _offset += sublen;
+
+ offset += sublen;
+ readLength += sublen;
+ length -= sublen;
+ _chunkLength -= sublen;
+ }
+
+ return readLength;
+ }
+
+ /**
+ * Normally, shouldn't be called externally, but needed for QA, e.g.
+ * ejb/3b01.
+ */
+ public final int read()
+ throws IOException
+ {
+ if (_length <= _offset && ! readBuffer())
+ return -1;
+
+ return _buffer[_offset++] & 0xff;
+ }
+
+ protected void unread()
+ {
+ if (_offset <= 0)
+ throw new IllegalStateException();
+
+ _offset--;
+ }
+
+ private final boolean readBuffer()
+ throws IOException
+ {
+ byte []buffer = _buffer;
+ int offset = _offset;
+ int length = _length;
+
+ if (offset < length) {
+ System.arraycopy(buffer, offset, buffer, 0, length - offset);
+ offset = length - offset;
+ }
+ else
+ offset = 0;
+
+ int len = 0;
+ if (_is != null)
+ len = _is.read(buffer, offset, SIZE - offset);
+
+ if (len <= 0) {
+ _length = offset;
+ _offset = 0;
+
+ return offset > 0;
+ }
+
+ _length = offset + len;
+ _offset = 0;
+
+ return true;
+ }
+
+ public Reader getReader()
+ {
+ return null;
+ }
+
+ protected IOException expect(String expect, int ch)
+ throws IOException
+ {
+ if (ch < 0)
+ return error("expected " + expect + " at end of file");
+ else {
+ _offset--;
+
+ try {
+ int offset = _offset;
+ String context
+ = buildDebugContext(_buffer, 0, _length, offset);
+
+ Object obj = readObject();
+
+ if (obj != null) {
+ return error("expected " + expect
+ + " at 0x" + Integer.toHexString(ch & 0xff)
+ + " " + obj.getClass().getName() + " (" + obj + ")"
+ + "\n " + context + "");
+ }
+ else
+ return error("expected " + expect
+ + " at 0x" + Integer.toHexString(ch & 0xff) + " null");
+ } catch (Exception e) {
+ log.log(Level.FINE, e.toString(), e);
+
+ return error("expected " + expect
+ + " at 0x" + Integer.toHexString(ch & 0xff));
+ }
+ }
+ }
+
+ private String buildDebugContext(byte []buffer, int offset, int length,
+ int errorOffset)
+ {
+ StringBuilder sb = new StringBuilder();
+
+ sb.append("[");
+ for (int i = 0; i < errorOffset; i++) {
+ int ch = buffer[offset + i];
+ addDebugChar(sb, ch);
+ }
+ sb.append("] ");
+ addDebugChar(sb, buffer[offset + errorOffset]);
+ sb.append(" [");
+ for (int i = errorOffset + 1; i < length; i++) {
+ int ch = buffer[offset + i];
+ addDebugChar(sb, ch);
+ }
+ sb.append("]");
+
+ return sb.toString();
+ }
+
+ private void addDebugChar(StringBuilder sb, int ch)
+ {
+ if (ch >= 0x20 && ch < 0x7f) {
+ sb.append((char) ch);
+ }
+ else if (ch == '\n')
+ sb.append((char) ch);
+ else
+ sb.append(String.format("\\x%02x", ch & 0xff));
+ }
+
+ protected String codeName(int ch)
+ {
+ if (ch < 0)
+ return "end of file";
+ else
+ return "0x" + Integer.toHexString(ch & 0xff) + " (" + (char) + ch + ")";
+ }
+
+ protected IOException error(String message)
+ {
+ if (_method != null)
+ return new HessianProtocolException(_method + ": " + message);
+ else
+ return new HessianProtocolException(message);
+ }
+
+ public void close()
+ throws IOException
+ {
+ InputStream is = _is;
+ _is = null;
+
+ if (_isCloseStreamOnClose && is != null)
+ is.close();
+ }
+
+ class ReadInputStream extends InputStream {
+ boolean _isClosed = false;
+
+ public int read()
+ throws IOException
+ {
+ if (_isClosed)
+ return -1;
+
+ int ch = parseByte();
+ if (ch < 0)
+ _isClosed = true;
+
+ return ch;
+ }
+
+ public int read(byte []buffer, int offset, int length)
+ throws IOException
+ {
+ if (_isClosed)
+ return -1;
+
+ int len = Hessian2Input.this.read(buffer, offset, length);
+ if (len < 0)
+ _isClosed = true;
+
+ return len;
+ }
+
+ public void close()
+ throws IOException
+ {
+ while (read() >= 0) {
+ }
+ }
+ };
+
+ final static class ObjectDefinition {
+ private final String _type;
+ private final Deserializer _reader;
+ private final Object []_fields;
+ private final String []_fieldNames;
+
+ ObjectDefinition(String type,
+ Deserializer reader,
+ Object []fields,
+ String []fieldNames)
+ {
+ _type = type;
+ _reader = reader;
+ _fields = fields;
+ _fieldNames = fieldNames;
+ }
+
+ String getType()
+ {
+ return _type;
+ }
+
+ Deserializer getReader()
+ {
+ return _reader;
+ }
+
+ Object []getFields()
+ {
+ return _fields;
+ }
+
+ String []getFieldNames()
+ {
+ return _fieldNames;
+ }
+ }
+
+ static {
+ try {
+ _detailMessageField = Throwable.class.getDeclaredField("detailMessage");
+ _detailMessageField.setAccessible(true);
+ } catch (Throwable e) {
+ }
+ }
+}
diff --git a/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/Hessian2Output.java b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/Hessian2Output.java
new file mode 100644
index 0000000000..c9fc90ec1c
--- /dev/null
+++ b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/Hessian2Output.java
@@ -0,0 +1,1733 @@
+/*
+ * Copyright (c) 2001-2008 Caucho Technology, Inc. All rights reserved.
+ *
+ * The Apache Software License, Version 1.1
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. 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.
+ *
+ * 3. The end-user documentation included with the redistribution, if
+ * any, must include the following acknowlegement:
+ * "This product includes software developed by the
+ * Caucho Technology (http://www.caucho.com/)."
+ * Alternately, this acknowlegement may appear in the software itself,
+ * if and wherever such third-party acknowlegements normally appear.
+ *
+ * 4. The names "Burlap", "Resin", and "Caucho" must not be used to
+ * endorse or promote products derived from this software without prior
+ * written permission. For written permission, please contact
+ * info@caucho.com.
+ *
+ * 5. Products derived from this software may not be called "Resin"
+ * nor may "Resin" appear in their names without prior written
+ * permission of Caucho Technology.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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 CAUCHO TECHNOLOGY OR ITS 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.
+ *
+ * @author Scott Ferguson
+ */
+
+package com.caucho.hessian4.io;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.HashMap;
+
+import org.jboss.netty.channel.ChannelFuture;
+
+import com.caucho.hessian4.util.IdentityIntMap;
+
+/**
+ * Output stream for Hessian 2 requests.
+ *
+ * Since HessianOutput does not depend on any classes other than
+ * in the JDK, it can be extracted independently into a smaller package.
+ *
+ *
HessianOutput is unbuffered, so any client needs to provide
+ * its own buffering.
+ *
+ *
+ * OutputStream os = ...; // from http connection
+ * Hessian2Output out = new Hessian2Output(os);
+ * String value;
+ *
+ * out.startCall("hello", 1); // start hello call
+ * out.writeString("arg1"); // write a string argument
+ * out.completeCall(); // complete the call
+ *
+ */
+public class Hessian2Output
+ extends AbstractHessianOutput
+ implements Hessian2Constants
+{
+ public final static int SIZE = 1024*1024;
+
+ // the output stream/
+ protected OutputStream _os;
+
+ // map of references
+ private final IdentityIntMap _refs
+ = new IdentityIntMap(256);
+
+ private boolean _isCloseStreamOnClose;
+
+ // map of classes
+ private final IdentityIntMap _classRefs
+ = new IdentityIntMap(256);
+
+ // map of types
+ private HashMap _typeRefs;
+
+ private final byte []_buffer = new byte[SIZE];
+ private int _offset;
+
+ private boolean _isPacket;
+
+ /**
+ * Creates a new Hessian output stream, initialized with an
+ * underlying output stream.
+ *
+ * @param os the underlying output stream.
+ */
+ public Hessian2Output(OutputStream os)
+ {
+ init(os);
+ }
+
+ public void init(OutputStream os)
+ {
+ _os = os;
+ reset();
+
+ }
+
+ public void setCloseStreamOnClose(boolean isClose)
+ {
+ _isCloseStreamOnClose = isClose;
+ }
+
+ public boolean isCloseStreamOnClose()
+ {
+ return _isCloseStreamOnClose;
+ }
+
+ /**
+ * Writes a complete method call.
+ */
+ @Override
+ public void call(String method, Object []args)
+ throws IOException
+ {
+ writeVersion();
+
+ int length = args != null ? args.length : 0;
+
+ startCall(method, length);
+
+ for (int i = 0; i < length; i++)
+ writeObject(args[i]);
+
+ completeCall();
+
+ flush();
+ }
+
+ /**
+ * Starts the method call. Clients would use startCall
+ * instead of call if they wanted finer control over
+ * writing the arguments, or needed to write headers.
+ *
+ *
+ * C
+ * string # method name
+ * int # arg count
+ *
+ * C
+ *
+ * E major minor
+ * m b16 b8 method-name
+ * A successful completion will have a single value:
+ *
+ *
+ * Z
+ *
+ */
+ public void completeEnvelope()
+ throws IOException
+ {
+ flushIfFull();
+
+ _buffer[_offset++] = (byte) 'Z';
+ }
+
+ /**
+ * Writes the method tag.
+ *
+ *
+ * string
+ *
+ * z
+ * A successful completion will have a single value:
+ *
+ *
+ * R
+ *
+ */
+ public void startReply()
+ throws IOException
+ {
+ writeVersion();
+
+ flushIfFull();
+
+ _buffer[_offset++] = (byte) 'R';
+ }
+
+ public void writeVersion()
+ throws IOException
+ {
+ flushIfFull();
+
+ _buffer[_offset++] = (byte) 'H';
+ _buffer[_offset++] = (byte) 2;
+ _buffer[_offset++] = (byte) 0;
+ }
+
+ /**
+ * Completes reading the reply
+ *
+ * A successful completion will have a single value:
+ *
+ *
+ * z
+ *
+ */
+ public void completeReply()
+ throws IOException
+ {
+ }
+
+ /**
+ * Starts a packet
+ *
+ * A message contains several objects encapsulated by a length
+ *
+ *
+ * p x02 x00
+ *
+ */
+ public void startMessage()
+ throws IOException
+ {
+ flushIfFull();
+
+ _buffer[_offset++] = (byte) 'p';
+ _buffer[_offset++] = (byte) 2;
+ _buffer[_offset++] = (byte) 0;
+ }
+
+ /**
+ * Completes reading the message
+ *
+ * A successful completion will have a single value:
+ *
+ *
+ * z
+ *
+ */
+ public void completeMessage()
+ throws IOException
+ {
+ flushIfFull();
+
+ _buffer[_offset++] = (byte) 'z';
+ }
+
+ /**
+ * Writes a fault. The fault will be written
+ * as a descriptive string followed by an object:
+ *
+ *
+ * F map
+ *
+ * F H
+ * \x04code
+ * \x10the fault code
+ *
+ * \x07message
+ * \x11the fault message
+ *
+ * \x06detail
+ * M\xnnjavax.ejb.FinderException
+ * ...
+ * Z
+ * Z
+ * writeListBegin followed by the list contents and then
+ * call writeListEnd.
+ *
+ *
+ * list ::= V type value* Z
+ * ::= v type int value*
+ * writeMapBegin followed by the map contents and then
+ * call writeMapEnd.
+ *
+ *
+ * map ::= M type ( )* Z
+ * ::= H ( )* Z
+ *
+ * C <string> <int> <string>*
+ *
+ * type ::= string
+ * ::= int
+ * ();
+
+ Integer typeRefV = (Integer) _typeRefs.get(type);
+
+ if (typeRefV != null) {
+ int typeRef = typeRefV.intValue();
+
+ writeInt(typeRef);
+ }
+ else {
+ _typeRefs.put(type, Integer.valueOf(_typeRefs.size()));
+
+ writeString(type);
+ }
+ }
+
+ /**
+ * Writes a boolean value to the stream. The boolean will be written
+ * with the following syntax:
+ *
+ *
+ * T
+ * F
+ *
+ * I b32 b24 b16 b8
+ *
+ * L b64 b56 b48 b40 b32 b24 b16 b8
+ *
+ * D b64 b56 b48 b40 b32 b24 b16 b8
+ *
+ * date ::= d b7 b6 b5 b4 b3 b2 b1 b0
+ * ::= x65 b3 b2 b1 b0
+ *
+ * N
+ *
+ * S b16 b8 string-value
+ *
+ * N
+ *
+ * S b16 b8 string-value
+ *
+ * N
+ *
+ * B b16 b18 bytes
+ *
+ * N
+ *
+ * B b16 b18 bytes
+ *
+ * N
+ *
+ *
+ * b b16 b18 bytes
+ *
+ * b b16 b18 bytes
+ *
+ * x51 <int>
+ * A streaming message starts with 'P'
+ *
+ *
+ * P x02 x00
+ *
+ */
+ public void writeStreamingObject(Object obj)
+ throws IOException
+ {
+ startPacket();
+
+ writeObject(obj);
+
+ endPacket();
+ }
+
+ /**
+ * Starts a streaming packet
+ *
+ * A streaming contains a set of chunks, ending with a zero chunk.
+ * Each chunk is a length followed by data where the length is
+ * encoded by (b1xxxxxxxx)* b0xxxxxxxx
+ */
+ public void startPacket()
+ throws IOException
+ {
+ if (_refs != null)
+ _refs.clear();
+
+ flushBuffer();
+
+ _isPacket = true;
+ _offset = 3;
+ _buffer[0] = (byte) 0x55;
+ _buffer[1] = (byte) 0x55;
+ _buffer[2] = (byte) 0x55;
+ }
+
+ public void endPacket()
+ throws IOException
+ {
+ int offset = _offset;
+
+ OutputStream os = _os;
+
+ if (os == null) {
+ _offset = 0;
+ return;
+ }
+
+ int len = offset - 3;
+
+ _buffer[0] = (byte) (0x80);
+ _buffer[1] = (byte) (0x80 + ((len >> 7) & 0x7f));
+ _buffer[2] = (byte) (len & 0x7f);
+
+ // end chunk
+ _buffer[offset++] = (byte) 0x80;
+ _buffer[offset++] = (byte) 0x00;
+
+ _isPacket = false;
+ _offset = 0;
+
+ if (os != null) {
+ if (len == 0) {
+ os.write(_buffer, 1, 2);
+ }
+ else if (len < 0x80) {
+ os.write(_buffer, 1, offset - 1);
+ }
+ else {
+ os.write(_buffer, 0, offset);
+ }
+ }
+ }
+
+ /**
+ * Prints a string to the stream, encoded as UTF-8 with preceeding length
+ *
+ * @param v the string to print.
+ */
+ public void printLenString(String v)
+ throws IOException
+ {
+ if (SIZE < _offset + 16)
+ flushBuffer();
+
+ if (v == null) {
+ _buffer[_offset++] = (byte) (0);
+ _buffer[_offset++] = (byte) (0);
+ }
+ else {
+ int len = v.length();
+ _buffer[_offset++] = (byte) (len >> 8);
+ _buffer[_offset++] = (byte) (len);
+
+ printString(v, 0, len);
+ }
+ }
+
+ /**
+ * Prints a string to the stream, encoded as UTF-8
+ *
+ * @param v the string to print.
+ */
+ public void printString(String v)
+ throws IOException
+ {
+ printString(v, 0, v.length());
+ }
+
+ /**
+ * Prints a string to the stream, encoded as UTF-8
+ *
+ * @param v the string to print.
+ */
+ public void printString(String v, int strOffset, int length)
+ throws IOException
+ {
+ int offset = _offset;
+ byte []buffer = _buffer;
+
+ for (int i = 0; i < length; i++) {
+ if (SIZE <= offset + 16) {
+ _offset = offset;
+ flushBuffer();
+ offset = _offset;
+ }
+
+ char ch = v.charAt(i + strOffset);
+
+ if (ch < 0x80)
+ buffer[offset++] = (byte) (ch);
+ else if (ch < 0x800) {
+ buffer[offset++] = (byte) (0xc0 + ((ch >> 6) & 0x1f));
+ buffer[offset++] = (byte) (0x80 + (ch & 0x3f));
+ }
+ else {
+ buffer[offset++] = (byte) (0xe0 + ((ch >> 12) & 0xf));
+ buffer[offset++] = (byte) (0x80 + ((ch >> 6) & 0x3f));
+ buffer[offset++] = (byte) (0x80 + (ch & 0x3f));
+ }
+ }
+
+ _offset = offset;
+ }
+
+ /**
+ * Prints a string to the stream, encoded as UTF-8
+ *
+ * @param v the string to print.
+ */
+ public void printString(char []v, int strOffset, int length)
+ throws IOException
+ {
+ int offset = _offset;
+ byte []buffer = _buffer;
+
+ for (int i = 0; i < length; i++) {
+ if (SIZE <= offset + 16) {
+ _offset = offset;
+ flushBuffer();
+ offset = _offset;
+ }
+
+ char ch = v[i + strOffset];
+
+ if (ch < 0x80)
+ buffer[offset++] = (byte) (ch);
+ else if (ch < 0x800) {
+ buffer[offset++] = (byte) (0xc0 + ((ch >> 6) & 0x1f));
+ buffer[offset++] = (byte) (0x80 + (ch & 0x3f));
+ }
+ else {
+ buffer[offset++] = (byte) (0xe0 + ((ch >> 12) & 0xf));
+ buffer[offset++] = (byte) (0x80 + ((ch >> 6) & 0x3f));
+ buffer[offset++] = (byte) (0x80 + (ch & 0x3f));
+ }
+ }
+
+ _offset = offset;
+ }
+
+ private final void flushIfFull()
+ throws IOException
+ {
+ int offset = _offset;
+
+ if (SIZE < offset + 32) {
+ flushBuffer();
+ }
+ }
+
+ public final void flush()
+ throws IOException
+{
+ flushBuffer();
+ _os.flush();
+}
+
+ public final void flush(ChannelFuture future)
+ throws IOException
+{
+ flushBuffer();
+ ((FlushableOutput)_os).flush(future);
+}
+
+ public final void flushBuffer()
+ throws IOException
+ {
+ if (_offset == 0)
+ return;
+ int offset = _offset;
+
+ OutputStream os = _os;
+
+ if (! _isPacket && offset > 0) {
+ _offset = 0;
+ if (os != null)
+ os.write(_buffer, 0, offset);
+ }
+ else if (_isPacket && offset > 3) {
+ int len = offset - 3;
+ _buffer[0] = (byte) 0x80;
+ _buffer[1] = (byte) (0x80 + ((len >> 7) & 0x7f));
+ _buffer[2] = (byte) (len & 0x7f);
+ _offset = 3;
+
+ if (os != null)
+ os.write(_buffer, 0, offset);
+
+ _buffer[0] = (byte) 0x56;
+ _buffer[1] = (byte) 0x56;
+ _buffer[2] = (byte) 0x56;
+
+ }
+ }
+
+ public void close()
+ throws IOException
+ {
+ // hessian/3a8c
+ flush();
+
+ OutputStream os = _os;
+ _os = null;
+
+ if (os != null) {
+ if (_isCloseStreamOnClose)
+ os.close();
+ }
+ }
+
+ public void free()
+ {
+ reset();
+
+ _os = null;
+ _isCloseStreamOnClose = false;
+ }
+
+ /**
+ * Resets the references for streaming.
+ */
+ @Override
+ public void resetReferences()
+ {
+ if (_refs != null)
+ _refs.clear();
+ }
+
+ /**
+ * Resets all counters and references
+ */
+ public void reset()
+ {
+ if (_refs != null)
+ _refs.clear();
+
+ _classRefs.clear();
+ _typeRefs = null;
+ _offset = 0;
+ _isPacket = false;
+ if (_os instanceof FlushableOutput)
+ ((FlushableOutput)_os).reset();
+ }
+
+ class BytesOutputStream extends OutputStream {
+ private int _startOffset;
+
+ BytesOutputStream()
+ throws IOException
+ {
+ if (SIZE < _offset + 16) {
+ Hessian2Output.this.flushBuffer();
+ }
+
+ _startOffset = _offset;
+ _offset += 3; // skip 'b' xNN xNN
+ }
+
+ @Override
+ public void write(int ch)
+ throws IOException
+ {
+ if (SIZE <= _offset) {
+ int length = (_offset - _startOffset) - 3;
+
+ _buffer[_startOffset] = (byte) BC_BINARY_CHUNK;
+ _buffer[_startOffset + 1] = (byte) (length >> 8);
+ _buffer[_startOffset + 2] = (byte) (length);
+
+ Hessian2Output.this.flushBuffer();
+
+ _startOffset = _offset;
+ _offset += 3;
+ }
+
+ _buffer[_offset++] = (byte) ch;
+ }
+
+ @Override
+ public void write(byte []buffer, int offset, int length)
+ throws IOException
+ {
+ while (length > 0) {
+ int sublen = SIZE - _offset;
+
+ if (length < sublen)
+ sublen = length;
+
+ if (sublen > 0) {
+ System.arraycopy(buffer, offset, _buffer, _offset, sublen);
+ _offset += sublen;
+ }
+
+ length -= sublen;
+ offset += sublen;
+
+ if (SIZE <= _offset) {
+ int chunkLength = (_offset - _startOffset) - 3;
+
+ _buffer[_startOffset] = (byte) BC_BINARY_CHUNK;
+ _buffer[_startOffset + 1] = (byte) (chunkLength >> 8);
+ _buffer[_startOffset + 2] = (byte) (chunkLength);
+
+ Hessian2Output.this.flushBuffer();
+
+ _startOffset = _offset;
+ _offset += 3;
+ }
+ }
+ }
+
+ @Override
+ public void close()
+ throws IOException
+ {
+ int startOffset = _startOffset;
+ _startOffset = -1;
+
+ if (startOffset < 0)
+ return;
+
+ int length = (_offset - startOffset) - 3;
+
+ _buffer[startOffset] = (byte) 'B';
+ _buffer[startOffset + 1] = (byte) (length >> 8);
+ _buffer[startOffset + 2] = (byte) (length);
+
+ Hessian2Output.this.flushBuffer();
+ }
+ }
+}
diff --git a/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/Hessian2StreamingInput.java b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/Hessian2StreamingInput.java
new file mode 100644
index 0000000000..a1452c707b
--- /dev/null
+++ b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/Hessian2StreamingInput.java
@@ -0,0 +1,276 @@
+/*
+ * Copyright (c) 2001-2008 Caucho Technology, Inc. All rights reserved.
+ *
+ * The Apache Software License, Version 1.1
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. 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.
+ *
+ * 3. The end-user documentation included with the redistribution, if
+ * any, must include the following acknowlegement:
+ * "This product includes software developed by the
+ * Caucho Technology (http://www.caucho.com/)."
+ * Alternately, this acknowlegement may appear in the software itself,
+ * if and wherever such third-party acknowlegements normally appear.
+ *
+ * 4. The names "Burlap", "Resin", and "Caucho" must not be used to
+ * endorse or promote products derived from this software without prior
+ * written permission. For written permission, please contact
+ * info@caucho.com.
+ *
+ * 5. Products derived from this software may not be called "Resin"
+ * nor may "Resin" appear in their names without prior written
+ * permission of Caucho Technology.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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 CAUCHO TECHNOLOGY OR ITS 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.
+ *
+ * @author Scott Ferguson
+ */
+
+package com.caucho.hessian4.io;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * Input stream for Hessian 2 streaming requests using WebSocket.
+ */
+public class Hessian2StreamingInput
+{
+ private static final Logger log
+ = Logger.getLogger(Hessian2StreamingInput.class.getName());
+
+ private StreamingInputStream _is;
+ private Hessian2Input _in;
+
+ /**
+ * Creates a new Hessian input stream, initialized with an
+ * underlying input stream.
+ *
+ * @param is the underlying output stream.
+ */
+ public Hessian2StreamingInput(InputStream is)
+ {
+ _is = new StreamingInputStream(is);
+ _in = new Hessian2Input(_is);
+ }
+
+ public void setSerializerFactory(SerializerFactory factory)
+ {
+ _in.setSerializerFactory(factory);
+ }
+
+ public boolean isDataAvailable()
+ {
+ StreamingInputStream is = _is;
+
+ return is != null && is.isDataAvailable();
+ }
+
+ public Hessian2Input startPacket()
+ throws IOException
+ {
+ if (_is.startPacket()) {
+ _in.resetReferences();
+ _in.resetBuffer(); // XXX:
+ return _in;
+ }
+ else
+ return null;
+ }
+
+ public void endPacket()
+ throws IOException
+ {
+ _is.endPacket();
+ _in.resetBuffer(); // XXX:
+ }
+
+ public Hessian2Input getHessianInput()
+ {
+ return _in;
+ }
+
+ /**
+ * Read the next object
+ */
+ public Object readObject()
+ throws IOException
+ {
+ _is.startPacket();
+
+ Object obj = _in.readStreamingObject();
+
+ _is.endPacket();
+
+ return obj;
+ }
+
+ /**
+ * Close the output.
+ */
+ public void close()
+ throws IOException
+ {
+ _in.close();
+ }
+
+ static class StreamingInputStream extends InputStream {
+ private InputStream _is;
+
+ private int _length;
+ private boolean _isPacketEnd;
+
+ StreamingInputStream(InputStream is)
+ {
+ _is = is;
+ }
+
+ public boolean isDataAvailable()
+ {
+ try {
+ return _is != null && _is.available() > 0;
+ } catch (IOException e) {
+ log.log(Level.FINER, e.toString(), e);
+
+ return true;
+ }
+ }
+
+ public boolean startPacket()
+ throws IOException
+ {
+ // skip zero-length packets
+ do {
+ _isPacketEnd = false;
+ } while ((_length = readChunkLength(_is)) == 0);
+
+ return _length > 0;
+ }
+
+ public void endPacket()
+ throws IOException
+ {
+ while (! _isPacketEnd) {
+ if (_length <= 0)
+ _length = readChunkLength(_is);
+
+ if (_length > 0)
+ _is.skip(_length);
+ }
+ }
+
+ public int read()
+ throws IOException
+ {
+ if (_isPacketEnd)
+ throw new IllegalStateException();
+
+ InputStream is = _is;
+
+ if (_length == 0) {
+ _length = readChunkLength(is);
+
+ if (_length <= 0)
+ return -1;
+ }
+
+ _length--;
+
+ return is.read();
+ }
+
+ public int read(byte []buffer, int offset, int length)
+ throws IOException
+ {
+ if (_isPacketEnd)
+ throw new IllegalStateException();
+
+ InputStream is = _is;
+
+ if (_length <= 0) {
+ _length = readChunkLength(is);
+
+ if (_length <= 0)
+ return -1;
+ }
+
+ int sublen = _length;
+ if (length < sublen)
+ sublen = length;
+
+ sublen = is.read(buffer, offset, sublen);
+
+ if (sublen < 0)
+ return -1;
+
+ _length -= sublen;
+
+ return sublen;
+ }
+
+ private int readChunkLength(InputStream is)
+ throws IOException
+ {
+ if (_isPacketEnd)
+ return -1;
+
+ int length = 0;
+
+ int code = is.read();
+
+ if (code < 0) {
+ _isPacketEnd = true;
+ return -1;
+ }
+ else if ((code & 0x80) != 0x80) {
+ int len = 256;
+ StringBuilder sb = new StringBuilder();
+ int ch;
+
+ while ((len-- > 0 && is.available() > 0 && (ch = is.read()) >= 0))
+ sb.append((char) ch);
+
+ throw new IllegalStateException("WebSocket binary must begin with a 0x80 packet at 0x" + Integer.toHexString(code)
+ + " ("+ (char) code + ")"
+ + " context[" + sb + "]");
+ }
+
+ while ((code = is.read()) >= 0) {
+ length = (length << 7) + (code & 0x7f);
+
+ if ((code & 0x80) == 0) {
+ if (length == 0)
+ _isPacketEnd = true;
+
+ return length;
+ }
+ }
+
+ _isPacketEnd = true;
+
+ return -1;
+ }
+ }
+}
diff --git a/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/Hessian2StreamingOutput.java b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/Hessian2StreamingOutput.java
new file mode 100644
index 0000000000..ee831f92ae
--- /dev/null
+++ b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/Hessian2StreamingOutput.java
@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) 2001-2008 Caucho Technology, Inc. All rights reserved.
+ *
+ * The Apache Software License, Version 1.1
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. 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.
+ *
+ * 3. The end-user documentation included with the redistribution, if
+ * any, must include the following acknowlegement:
+ * "This product includes software developed by the
+ * Caucho Technology (http://www.caucho.com/)."
+ * Alternately, this acknowlegement may appear in the software itself,
+ * if and wherever such third-party acknowlegements normally appear.
+ *
+ * 4. The names "Burlap", "Resin", and "Caucho" must not be used to
+ * endorse or promote products derived from this software without prior
+ * written permission. For written permission, please contact
+ * info@caucho.com.
+ *
+ * 5. Products derived from this software may not be called "Resin"
+ * nor may "Resin" appear in their names without prior written
+ * permission of Caucho Technology.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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 CAUCHO TECHNOLOGY OR ITS 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.
+ *
+ * @author Scott Ferguson
+ */
+
+package com.caucho.hessian4.io;
+
+import java.io.IOException;
+import java.io.OutputStream;
+
+/**
+ * Output stream for Hessian 2 streaming requests.
+ */
+public class Hessian2StreamingOutput
+{
+ private Hessian2Output _out;
+
+ /**
+ * Creates a new Hessian output stream, initialized with an
+ * underlying output stream.
+ *
+ * @param os the underlying output stream.
+ */
+ public Hessian2StreamingOutput(OutputStream os)
+ {
+ _out = new Hessian2Output(os);
+ }
+
+ public Hessian2StreamingOutput(Hessian2Output out)
+ {
+ _out = out;
+ }
+
+ public Hessian2Output getHessian2Output()
+ {
+ return _out;
+ }
+
+ public void setCloseStreamOnClose(boolean isClose)
+ {
+ _out.setCloseStreamOnClose(isClose);
+ }
+
+ public boolean isCloseStreamOnClose()
+ {
+ return _out.isCloseStreamOnClose();
+ }
+
+ /**
+ * Writes any object to the output stream.
+ */
+ public void writeObject(Object object)
+ throws IOException
+ {
+ _out.writeStreamingObject(object);
+ }
+
+ /**
+ * Flushes the output.
+ */
+ public void flush()
+ throws IOException
+ {
+ _out.flush();
+ }
+
+ /**
+ * Close the output.
+ */
+ public void close()
+ throws IOException
+ {
+ _out.close();
+ }
+}
diff --git a/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/HessianDebugInputStream.java b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/HessianDebugInputStream.java
new file mode 100644
index 0000000000..314fbcf3f6
--- /dev/null
+++ b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/HessianDebugInputStream.java
@@ -0,0 +1,196 @@
+/*
+ * Copyright (c) 2001-2008 Caucho Technology, Inc. All rights reserved.
+ *
+ * The Apache Software License, Version 1.1
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. 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.
+ *
+ * 3. The end-user documentation included with the redistribution, if
+ * any, must include the following acknowlegement:
+ * "This product includes software developed by the
+ * Caucho Technology (http://www.caucho.com/)."
+ * Alternately, this acknowlegement may appear in the software itself,
+ * if and wherever such third-party acknowlegements normally appear.
+ *
+ * 4. The names "Hessian", "Resin", and "Caucho" must not be used to
+ * endorse or promote products derived from this software without prior
+ * written permission. For written permission, please contact
+ * info@caucho.com.
+ *
+ * 5. Products derived from this software may not be called "Resin"
+ * nor may "Resin" appear in their names without prior written
+ * permission of Caucho Technology.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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 CAUCHO TECHNOLOGY OR ITS 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.
+ *
+ * @author Scott Ferguson
+ */
+
+package com.caucho.hessian4.io;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.PrintWriter;
+import java.io.Writer;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * Debugging input stream for Hessian requests.
+ */
+public class HessianDebugInputStream extends InputStream
+{
+ private InputStream _is;
+
+ private HessianDebugState _state;
+
+ /**
+ * Creates an uninitialized Hessian input stream.
+ */
+ public HessianDebugInputStream(InputStream is, OutputStream os)
+ {
+ this(is, new PrintWriter(os));
+ }
+
+ /**
+ * Creates an uninitialized Hessian input stream.
+ */
+ public HessianDebugInputStream(InputStream is, PrintWriter dbg)
+ {
+ _is = is;
+
+ if (dbg == null)
+ dbg = new PrintWriter(System.out);
+
+ _state = new HessianDebugState(dbg);
+ }
+
+ /**
+ * Creates an uninitialized Hessian input stream.
+ */
+ public HessianDebugInputStream(InputStream is, Logger log, Level level)
+ {
+ this(is, new PrintWriter(new LogWriter(log, level)));
+ }
+
+ public void startTop2()
+ {
+ _state.startTop2();
+ }
+
+ public void startData1()
+ {
+ _state.startData1();
+ }
+
+ public void startStreaming()
+ {
+ _state.startStreaming();
+ }
+
+ public void setDepth(int depth)
+ {
+ _state.setDepth(depth);
+ }
+
+ /**
+ * Reads a character.
+ */
+ public int read()
+ throws IOException
+ {
+ int ch;
+
+ InputStream is = _is;
+
+ if (is == null)
+ return -1;
+ else {
+ ch = is.read();
+ }
+
+ _state.next(ch);
+
+ return ch;
+ }
+
+ /**
+ * closes the stream.
+ */
+ public void close()
+ throws IOException
+ {
+ InputStream is = _is;
+ _is = null;
+
+ if (is != null)
+ is.close();
+
+ _state.println();
+ }
+
+ static class LogWriter extends Writer {
+ private Logger _log;
+ private Level _level;
+ private StringBuilder _sb = new StringBuilder();
+
+ LogWriter(Logger log, Level level)
+ {
+ _log = log;
+ _level = level;
+ }
+
+ public void write(char ch)
+ {
+ if (ch == '\n' && _sb.length() > 0) {
+ _log.log(_level, _sb.toString());
+ _sb.setLength(0);
+ }
+ else
+ _sb.append((char) ch);
+ }
+
+ public void write(char []buffer, int offset, int length)
+ {
+ for (int i = 0; i < length; i++) {
+ char ch = buffer[offset + i];
+
+ if (ch == '\n' && _sb.length() > 0) {
+ _log.log(_level, _sb.toString());
+ _sb.setLength(0);
+ }
+ else
+ _sb.append((char) ch);
+ }
+ }
+
+ public void flush()
+ {
+ }
+
+ public void close()
+ {
+ }
+ }
+}
diff --git a/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/HessianDebugOutputStream.java b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/HessianDebugOutputStream.java
new file mode 100644
index 0000000000..b6c96ed9dd
--- /dev/null
+++ b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/HessianDebugOutputStream.java
@@ -0,0 +1,174 @@
+/*
+ * Copyright (c) 2001-2004 Caucho Technology, Inc. All rights reserved.
+ *
+ * The Apache Software License, Version 1.1
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. 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.
+ *
+ * 3. The end-user documentation included with the redistribution, if
+ * any, must include the following acknowlegement:
+ * "This product includes software developed by the
+ * Caucho Technology (http://www.caucho.com/)."
+ * Alternately, this acknowlegement may appear in the software itself,
+ * if and wherever such third-party acknowlegements normally appear.
+ *
+ * 4. The names "Hessian", "Resin", and "Caucho" must not be used to
+ * endorse or promote products derived from this software without prior
+ * written permission. For written permission, please contact
+ * info@caucho.com.
+ *
+ * 5. Products derived from this software may not be called "Resin"
+ * nor may "Resin" appear in their names without prior written
+ * permission of Caucho Technology.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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 CAUCHO TECHNOLOGY OR ITS 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.
+ *
+ * @author Scott Ferguson
+ */
+
+package com.caucho.hessian4.io;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.PrintWriter;
+import java.io.Writer;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * Debugging output stream for Hessian requests.
+ */
+public class HessianDebugOutputStream extends OutputStream
+{
+ private OutputStream _os;
+
+ private HessianDebugState _state;
+
+ /**
+ * Creates an uninitialized Hessian input stream.
+ */
+ public HessianDebugOutputStream(OutputStream os, PrintWriter dbg)
+ {
+ _os = os;
+
+ _state = new HessianDebugState(dbg);
+ }
+
+ /**
+ * Creates an uninitialized Hessian input stream.
+ */
+ public HessianDebugOutputStream(OutputStream os, Logger log, Level level)
+ {
+ this(os, new PrintWriter(new LogWriter(log, level)));
+ }
+
+ public void startTop2()
+ {
+ _state.startTop2();
+ }
+
+ public void startStreaming()
+ {
+ _state.startStreaming();
+ }
+
+ /**
+ * Writes a character.
+ */
+ public void write(int ch)
+ throws IOException
+ {
+ ch = ch & 0xff;
+
+ _os.write(ch);
+
+ _state.next(ch);
+ }
+
+ public void flush()
+ throws IOException
+ {
+ _os.flush();
+ }
+
+ /**
+ * closes the stream.
+ */
+ public void close()
+ throws IOException
+ {
+ OutputStream os = _os;
+ _os = null;
+
+ if (os != null) {
+ _state.next(-1);
+ os.close();
+ }
+
+ _state.println();
+ }
+
+ static class LogWriter extends Writer {
+ private Logger _log;
+ private Level _level;
+ private StringBuilder _sb = new StringBuilder();
+
+ LogWriter(Logger log, Level level)
+ {
+ _log = log;
+ _level = level;
+ }
+
+ public void write(char ch)
+ {
+ if (ch == '\n' && _sb.length() > 0) {
+ _log.log(_level, _sb.toString());
+ _sb.setLength(0);
+ }
+ else
+ _sb.append((char) ch);
+ }
+
+ public void write(char []buffer, int offset, int length)
+ {
+ for (int i = 0; i < length; i++) {
+ char ch = buffer[offset + i];
+
+ if (ch == '\n' && _sb.length() > 0) {
+ _log.log(_level, _sb.toString());
+ _sb.setLength(0);
+ }
+ else
+ _sb.append((char) ch);
+ }
+ }
+
+ public void flush()
+ {
+ }
+
+ public void close()
+ {
+ }
+ }
+}
diff --git a/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/HessianDebugState.java b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/HessianDebugState.java
new file mode 100644
index 0000000000..f7a61486fa
--- /dev/null
+++ b/javaUtilities/yajsw/src/hessian/com/caucho/hessian4/io/HessianDebugState.java
@@ -0,0 +1,2506 @@
+/*
+ * Copyright (c) 2001-2004 Caucho Technology, Inc. All rights reserved.
+ *
+ * The Apache Software License, Version 1.1
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. 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.
+ *
+ * 3. The end-user documentation included with the redistribution, if
+ * any, must include the following acknowlegement:
+ * "This product includes software developed by the
+ * Caucho Technology (http://www.caucho.com/)."
+ * Alternately, this acknowlegement may appear in the software itself,
+ * if and wherever such third-party acknowlegements normally appear.
+ *
+ * 4. The names "Hessian", "Resin", and "Caucho" must not be used to
+ * endorse or promote products derived from this software without prior
+ * written permission. For written permission, please contact
+ * info@caucho.com.
+ *
+ * 5. Products derived from this software may not be called "Resin"
+ * nor may "Resin" appear in their names without prior written
+ * permission of Caucho Technology.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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 CAUCHO TECHNOLOGY OR ITS 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.
+ *
+ * @author Scott Ferguson
+ */
+
+package com.caucho.hessian4.io;
+
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+
+/**
+ * Debugging input stream for Hessian requests.
+ */
+public class HessianDebugState implements Hessian2Constants
+{
+ private PrintWriter _dbg;
+
+ private State _state;
+ private ArrayList _stateStack = new ArrayList();
+
+ private ArrayList _objectDefList
+ = new ArrayList();
+
+ private ArrayList _typeDefList
+ = new ArrayList();
+
+ private int _refId;
+ private boolean _isNewline = true;
+ private boolean _isObject = false;
+ private int _column;
+
+ private int _depth = 0;
+
+ /**
+ * Creates an uninitialized Hessian input stream.
+ */
+ public HessianDebugState(PrintWriter dbg)
+ {
+ _dbg = dbg;
+
+ _state = new InitialState();
+ }
+
+ public void startTop2()
+ {
+ _state = new Top2State();
+ }
+
+ public void startData1()
+ {
+ _state = new InitialState1();
+ }
+
+ public void startStreaming()
+ {
+ _state = new StreamingState(new InitialState(), false);
+ }
+
+ /**
+ * Reads a character.
+ */
+ public void next(int ch)
+ throws IOException
+ {
+ _state = _state.next(ch);
+ }
+
+ void pushStack(State state)
+ {
+ _stateStack.add(state);
+ }
+
+ State popStack()
+ {
+ return _stateStack.remove(_stateStack.size() - 1);
+ }
+
+ public void setDepth(int depth)
+ {
+ _depth = depth;
+ }
+
+ public int getDepth()
+ {
+ return _depth;
+ }
+
+ void println()
+ {
+ if (! _isNewline) {
+ _dbg.println();
+ _dbg.flush();
+ }
+
+ _isNewline = true;
+ _column = 0;
+ }
+
+ static boolean isString(int ch)
+ {
+ switch (ch) {
+ case 0x00: case 0x01: case 0x02: case 0x03:
+ case 0x04: case 0x05: case 0x06: case 0x07:
+ case 0x08: case 0x09: case 0x0a: case 0x0b:
+ case 0x0c: case 0x0d: case 0x0e: case 0x0f:
+
+ case 0x10: case 0x11: case 0x12: case 0x13:
+ case 0x14: case 0x15: case 0x16: case 0x17:
+ case 0x18: case 0x19: case 0x1a: case 0x1b:
+ case 0x1c: case 0x1d: case 0x1e: case 0x1f:
+
+ case 0x30: case 0x31: case 0x32: case 0x33:
+
+ case 'R':
+ case 'S':
+ return true;
+
+ default:
+ return false;
+ }
+ }
+
+ static boolean isInteger(int ch)
+ {
+ switch (ch) {
+ case 0x80: case 0x81: case 0x82: case 0x83:
+ case 0x84: case 0x85: case 0x86: case 0x87:
+ case 0x88: case 0x89: case 0x8a: case 0x8b:
+ case 0x8c: case 0x8d: case 0x8e: case 0x8f:
+
+ case 0x90: case 0x91: case 0x92: case 0x93:
+ case 0x94: case 0x95: case 0x96: case 0x97:
+ case 0x98: case 0x99: case 0x9a: case 0x9b:
+ case 0x9c: case 0x9d: case 0x9e: case 0x9f:
+
+ case 0xa0: case 0xa1: case 0xa2: case 0xa3:
+ case 0xa4: case 0xa5: case 0xa6: case 0xa7:
+ case 0xa8: case 0xa9: case 0xaa: case 0xab:
+ case 0xac: case 0xad: case 0xae: case 0xaf:
+
+ case 0xb0: case 0xb1: case 0xb2: case 0xb3:
+ case 0xb4: case 0xb5: case 0xb6: case 0xb7:
+ case 0xb8: case 0xb9: case 0xba: case 0xbb:
+ case 0xbc: case 0xbd: case 0xbe: case 0xbf:
+
+ case 0xc0: case 0xc1: case 0xc2: case 0xc3:
+ case 0xc4: case 0xc5: case 0xc6: case 0xc7:
+ case 0xc8: case 0xc9: case 0xca: case 0xcb:
+ case 0xcc: case 0xcd: case 0xce: case 0xcf:
+
+ case 0xd0: case 0xd1: case 0xd2: case 0xd3:
+ case 0xd4: case 0xd5: case 0xd6: case 0xd7:
+
+ case 'I':
+ return true;
+
+ default:
+ return false;
+ }
+ }
+
+ abstract class State {
+ State _next;
+
+ State()
+ {
+ }
+
+ State(State next)
+ {
+ _next = next;
+ }
+
+ abstract State next(int ch);
+
+ boolean isShift(Object value)
+ {
+ return false;
+ }
+
+ State shift(Object value)
+ {
+ return this;
+ }
+
+ int depth()
+ {
+ if (_next != null)
+ return _next.depth();
+ else
+ return HessianDebugState.this.getDepth();
+ }
+
+ void printIndent(int depth)
+ {
+ if (_isNewline) {
+ for (int i = _column; i < depth() + depth; i++) {
+ _dbg.print(" ");
+ _column++;
+ }
+ }
+ }
+
+ void print(String string)
+ {
+ print(0, string);
+ }
+
+ void print(int depth, String string)
+ {
+ printIndent(depth);
+
+ _dbg.print(string);
+ _isNewline = false;
+ _isObject = false;
+
+ int p = string.lastIndexOf('\n');
+ if (p > 0)
+ _column = string.length() - p - 1;
+ else
+ _column += string.length();
+ }
+
+ void println(String string)
+ {
+ println(0, string);
+ }
+
+ void println(int depth, String string)
+ {
+ printIndent(depth);
+
+ _dbg.println(string);
+ _dbg.flush();
+ _isNewline = true;
+ _isObject = false;
+ _column = 0;
+ }
+
+ void println()
+ {
+ if (! _isNewline) {
+ _dbg.println();
+ _dbg.flush();
+ }
+
+ _isNewline = true;
+ _isObject = false;
+ _column = 0;
+ }
+
+ void printObject(String string)
+ {
+ if (_isObject)
+ println();
+
+ printIndent(0);
+
+ _dbg.print(string);
+ _dbg.flush();
+
+ _column += string.length();
+
+ _isNewline = false;
+ _isObject = true;
+ }
+
+ protected State nextObject(int ch)
+ {
+ switch (ch) {
+ case -1:
+ println();
+ return this;
+
+ case 'N':
+ if (isShift(null))
+ return shift(null);
+ else {
+ printObject("null");
+ return this;
+ }
+
+ case 'T':
+ if (isShift(Boolean.TRUE))
+ return shift(Boolean.TRUE);
+ else {
+ printObject("true");
+ return this;
+ }
+
+ case 'F':
+ if (isShift(Boolean.FALSE))
+ return shift(Boolean.FALSE);
+ else {
+ printObject("false");
+ return this;
+ }
+
+ case 0x80: case 0x81: case 0x82: case 0x83:
+ case 0x84: case 0x85: case 0x86: case 0x87:
+ case 0x88: case 0x89: case 0x8a: case 0x8b:
+ case 0x8c: case 0x8d: case 0x8e: case 0x8f:
+
+ case 0x90: case 0x91: case 0x92: case 0x93:
+ case 0x94: case 0x95: case 0x96: case 0x97:
+ case 0x98: case 0x99: case 0x9a: case 0x9b:
+ case 0x9c: case 0x9d: case 0x9e: case 0x9f:
+
+ case 0xa0: case 0xa1: case 0xa2: case 0xa3:
+ case 0xa4: case 0xa5: case 0xa6: case 0xa7:
+ case 0xa8: case 0xa9: case 0xaa: case 0xab:
+ case 0xac: case 0xad: case 0xae: case 0xaf:
+
+ case 0xb0: case 0xb1: case 0xb2: case 0xb3:
+ case 0xb4: case 0xb5: case 0xb6: case 0xb7:
+ case 0xb8: case 0xb9: case 0xba: case 0xbb:
+ case 0xbc: case 0xbd: case 0xbe: case 0xbf:
+ {
+ Integer value = new Integer(ch - 0x90);
+
+ if (isShift(value))
+ return shift(value);
+ else {
+ printObject(value.toString());
+ return this;
+ }
+ }
+
+ case 0xc0: case 0xc1: case 0xc2: case 0xc3:
+ case 0xc4: case 0xc5: case 0xc6: case 0xc7:
+ case 0xc8: case 0xc9: case 0xca: case 0xcb:
+ case 0xcc: case 0xcd: case 0xce: case 0xcf:
+ return new IntegerState(this, "int", ch - 0xc8, 3);
+
+ case 0xd0: case 0xd1: case 0xd2: case 0xd3:
+ case 0xd4: case 0xd5: case 0xd6: case 0xd7:
+ return new IntegerState(this, "int", ch - 0xd4, 2);
+
+ case 'I':
+ return new IntegerState(this, "int");
+
+ case 0xd8: case 0xd9: case 0xda: case 0xdb:
+ case 0xdc: case 0xdd: case 0xde: case 0xdf:
+ case 0xe0: case 0xe1: case 0xe2: case 0xe3:
+ case 0xe4: case 0xe5: case 0xe6: case 0xe7:
+ case 0xe8: case 0xe9: case 0xea: case 0xeb:
+ case 0xec: case 0xed: case 0xee: case 0xef:
+ {
+ Long value = new Long(ch - 0xe0);
+
+ if (isShift(value))
+ return shift(value);
+ else {
+ printObject(value.toString() + "L");
+ return this;
+ }
+ }
+
+ case 0xf0: case 0xf1: case 0xf2: case 0xf3:
+ case 0xf4: case 0xf5: case 0xf6: case 0xf7:
+ case 0xf8: case 0xf9: case 0xfa: case 0xfb:
+ case 0xfc: case 0xfd: case 0xfe: case 0xff:
+ return new LongState(this, "long", ch - 0xf8, 7);
+
+ case 0x38: case 0x39: case 0x3a: case 0x3b:
+ case 0x3c: case 0x3d: case 0x3e: case 0x3f:
+ return new LongState(this, "long", ch - 0x3c, 6);
+
+ case BC_LONG_INT:
+ return new LongState(this, "long", 0, 4);
+
+ case 'L':
+ return new LongState(this, "long");
+
+ case 0x5b: case 0x5c:
+ {
+ Double value = new Double(ch - 0x5b);
+
+ if (isShift(value))
+ return shift(value);
+ else {
+ printObject(value.toString());
+ return this;
+ }
+ }
+
+ case 0x5d:
+ return new DoubleIntegerState(this, 3);
+
+ case 0x5e:
+ return new DoubleIntegerState(this, 2);
+
+ case 0x5f:
+ return new MillsState(this);
+
+ case 'D':
+ return new DoubleState(this);
+
+ case 'Q':
+ return new RefState(this);
+
+ case BC_DATE:
+ return new DateState(this);
+
+ case BC_DATE_MINUTE:
+ return new DateState(this, true);
+
+ case 0x00:
+ {
+ String value = "\"\"";
+
+ if (isShift(value))
+ return shift(value);
+ else {
+ printObject(value.toString());
+ return this;
+ }
+ }
+
+ case 0x01: case 0x02: case 0x03:
+ case 0x04: case 0x05: case 0x06: case 0x07:
+ case 0x08: case 0x09: case 0x0a: case 0x0b:
+ case 0x0c: case 0x0d: case 0x0e: case 0x0f:
+
+ case 0x10: case 0x11: case 0x12: case 0x13:
+ case 0x14: case 0x15: case 0x16: case 0x17:
+ case 0x18: case 0x19: case 0x1a: case 0x1b:
+ case 0x1c: case 0x1d: case 0x1e: case 0x1f:
+ return new StringState(this, 'S', ch);
+
+ case 0x30: case 0x31: case 0x32: case 0x33:
+ return new StringState(this, 'S', ch - 0x30, true);
+
+ case 'R':
+ return new StringState(this, 'S', false);
+
+ case 'S':
+ return new StringState(this, 'S', true);
+
+ case 0x20:
+ {
+ String value = "binary(0)";
+
+ if (isShift(value))
+ return shift(value);
+ else {
+ printObject(value.toString());
+ return this;
+ }
+ }
+
+ case 0x21: case 0x22: case 0x23:
+ case 0x24: case 0x25: case 0x26: case 0x27:
+ case 0x28: case 0x29: case 0x2a: case 0x2b:
+ case 0x2c: case 0x2d: case 0x2e: case 0x2f:
+ return new BinaryState(this, 'B', ch - 0x20);
+
+ case 0x34: case 0x35: case 0x36: case 0x37:
+ return new BinaryState(this, 'B', ch - 0x34, true);
+
+ case 'A':
+ return new BinaryState(this, 'B', false);
+
+ case 'B':
+ return new BinaryState(this, 'B', true);
+
+ case 'M':
+ return new MapState(this, _refId++);
+
+ case 'H':
+ return new MapState(this, _refId++, false);
+
+ case BC_LIST_VARIABLE:
+ return new ListState(this, _refId++, true);
+
+ case BC_LIST_VARIABLE_UNTYPED:
+ return new ListState(this, _refId++, false);
+
+ case BC_LIST_FIXED:
+ return new CompactListState(this, _refId++, true);
+
+ case BC_LIST_FIXED_UNTYPED:
+ return new CompactListState(this, _refId++, false);
+
+ case 0x70: case 0x71: case 0x72: case 0x73:
+ case 0x74: case 0x75: case 0x76: case 0x77:
+ return new CompactListState(this, _refId++, true, ch - 0x70);
+
+ case 0x78: case 0x79: case 0x7a: case 0x7b:
+ case 0x7c: case 0x7d: case 0x7e: case 0x7f:
+ return new CompactListState(this, _refId++, false, ch - 0x78);
+
+ case 'C':
+ return new ObjectDefState(this);
+
+ case 0x60: case 0x61: case 0x62: case 0x63:
+ case 0x64: case 0x65: case 0x66: case 0x67:
+ case 0x68: case 0x69: case 0x6a: case 0x6b:
+ case 0x6c: case 0x6d: case 0x6e: case 0x6f:
+ return new ObjectState(this, _refId++, ch - 0x60);
+
+ case 'O':
+ return new ObjectState(this, _refId++);
+
+ default:
+ return this;
+ }
+ }
+ }
+
+ abstract class State1 extends State {
+ State1()
+ {
+ }
+
+ State1(State next)
+ {
+ super(next);
+ }
+
+ protected State nextObject(int ch)
+ {
+ switch (ch) {
+ case -1:
+ println();
+ return this;
+
+ case 'N':
+ if (isShift(null))
+ return shift(null);
+ else {
+ printObject("null");
+ return this;
+ }
+
+ case 'T':
+ if (isShift(Boolean.TRUE))
+ return shift(Boolean.TRUE);
+ else {
+ printObject("true");
+ return this;
+ }
+
+ case 'F':
+ if (isShift(Boolean.FALSE))
+ return shift(Boolean.FALSE);
+ else {
+ printObject("false");
+ return this;
+ }
+
+ case 'I':
+ return new IntegerState(this, "int");
+
+ case 'L':
+ return new LongState(this, "long");
+
+ case 'D':
+ return new DoubleState(this);
+
+ case 'Q':
+ return new RefState(this);
+
+ case 'd':
+ return new DateState(this);
+
+ case 's':
+ return new StringState(this, 'S', false);
+
+ case 'S':
+ return new StringState(this, 'S', true);
+
+ case 'b':
+ return new BinaryState(this, 'B', false);
+
+ case 'B':
+ return new BinaryState(this, 'B', true);
+
+ case 'M':
+ return new MapState1(this, _refId++);
+
+ case 'V':
+ return new ListState1(this, _refId++);
+
+ case 'R':
+ return new IntegerState(new RefState1(this), "ref");
+
+ default:
+ printObject("x" + String.format("%02x", ch));
+ return this;
+ }
+ }
+ }
+
+ class InitialState extends State {
+ State next(int ch)
+ {
+ return nextObject(ch);
+ }
+ }
+
+ class InitialState1 extends State1 {
+ State next(int ch)
+ {
+ return nextObject(ch);
+ }
+ }
+
+ class Top1State extends State1 {
+ State next(int ch)
+ {
+ println();
+
+ if (ch == 'r') {
+ return new ReplyState1(this);
+ }
+ else if (ch == 'c') {
+ return new CallState1(this);
+ }
+ else
+ return nextObject(ch);
+ }
+ }
+
+ class Top2State extends State {
+ State next(int ch)
+ {
+ println();
+
+ if (ch == 'R') {
+ return new Reply2State(this);
+ }
+ else if (ch == 'F') {
+ return new Fault2State(this);
+ }
+ else if (ch == 'C') {
+ return new Call2State(this);
+ }
+ else if (ch == 'H') {
+ return new Hessian2State(this);
+ }
+ else if (ch == 'r') {
+ return new ReplyState1(this);
+ }
+ else if (ch == 'c') {
+ return new CallState1(this);
+ }
+ else
+ return nextObject(ch);
+ }
+ }
+
+ class IntegerState extends State {
+ String _typeCode;
+
+ int _length;
+ int _value;
+
+ IntegerState(State next, String typeCode)
+ {
+ super(next);
+
+ _typeCode = typeCode;
+ }
+
+ IntegerState(State next, String typeCode, int value, int length)
+ {
+ super(next);
+
+ _typeCode = typeCode;
+
+ _value = value;
+ _length = length;
+ }
+
+ State next(int ch)
+ {
+ _value = 256 * _value + (ch & 0xff);
+
+ if (++_length == 4) {
+ Integer value = new Integer(_value);
+
+ if (_next.isShift(value))
+ return _next.shift(value);
+ else {
+ printObject(value.toString());
+
+ return _next;
+ }
+ }
+ else
+ return this;
+ }
+ }
+
+ class LongState extends State {
+ String _typeCode;
+
+ int _length;
+ long _value;
+
+ LongState(State next, String typeCode)
+ {
+ super(next);
+
+ _typeCode = typeCode;
+ }
+
+ LongState(State next, String typeCode, long value, int length)
+ {
+ super(next);
+
+ _typeCode = typeCode;
+
+ _value = value;
+ _length = length;
+ }
+
+ State next(int ch)
+ {
+ _value = 256 * _value + (ch & 0xff);
+
+ if (++_length == 8) {
+ Long value = new Long(_value);
+
+ if (_next.isShift(value))
+ return _next.shift(value);
+ else {
+ printObject(value.toString() + "L");
+
+ return _next;
+ }
+ }
+ else
+ return this;
+ }
+ }
+
+ class DoubleIntegerState extends State {
+ int _length;
+ int _value;
+ boolean _isFirst = true;
+
+ DoubleIntegerState(State next, int length)
+ {
+ super(next);
+
+ _length = length;
+ }
+
+ State next(int ch)
+ {
+ if (_isFirst)
+ _value = (byte) ch;
+ else
+ _value = 256 * _value + (ch & 0xff);
+
+ _isFirst = false;
+
+ if (++_length == 4) {
+ Double value = new Double(_value);
+
+ if (_next.isShift(value))
+ return _next.shift(value);
+ else {
+ printObject(value.toString());
+
+ return _next;
+ }
+ }
+ else
+ return this;
+ }
+ }
+
+ class RefState extends State {
+ String _typeCode;
+
+ int _length;
+ int _value;
+
+ RefState(State next)
+ {
+ super(next);
+ }
+
+ RefState(State next, String typeCode)
+ {
+ super(next);
+
+ _typeCode = typeCode;
+ }
+
+ RefState(State next, String typeCode, int value, int length)
+ {
+ super(next);
+
+ _typeCode = typeCode;
+
+ _value = value;
+ _length = length;
+ }
+
+ @Override
+ boolean isShift(Object o)
+ {
+ return true;
+ }
+
+ @Override
+ State shift(Object o)
+ {
+ println("ref #" + o);
+
+ return _next;
+ }
+
+ @Override
+ State next(int ch)
+ {
+ return nextObject(ch);
+ }
+ }
+
+ class RefState1 extends State {
+ String _typeCode;
+
+ RefState1(State next)
+ {
+ super(next);
+ }
+
+ @Override
+ boolean isShift(Object o)
+ {
+ return true;
+ }
+
+ @Override
+ State shift(Object o)
+ {
+ println("ref #" + o);
+
+ return _next;
+ }
+
+ @Override
+ State next(int ch)
+ {
+ return nextObject(ch);
+ }
+ }
+
+ class DateState extends State {
+ int _length;
+ long _value;
+ boolean _isMinute;
+
+ DateState(State next)
+ {
+ super(next);
+ }
+
+ DateState(State next, boolean isMinute)
+ {
+ super(next);
+
+ _length = 4;
+ _isMinute = isMinute;
+ }
+
+
+ State next(int ch)
+ {
+ _value = 256 * _value + (ch & 0xff);
+
+ if (++_length == 8) {
+ java.util.Date value;
+
+ if (_isMinute)
+ value = new java.util.Date(_value * 60000L);
+ else
+ value = new java.util.Date(_value);
+
+ if (_next.isShift(value))
+ return _next.shift(value);
+ else {
+ printObject(value.toString());
+
+ return _next;
+ }
+ }
+ else
+ return this;
+ }
+ }
+
+ class DoubleState extends State {
+ int _length;
+ long _value;
+
+ DoubleState(State next)
+ {
+ super(next);
+ }
+
+ State next(int ch)
+ {
+ _value = 256 * _value + (ch & 0xff);
+
+ if (++_length == 8) {
+ Double value = Double.longBitsToDouble(_value);
+
+ if (_next.isShift(value))
+ return _next.shift(value);
+ else {
+ printObject(value.toString());
+
+ return _next;
+ }
+ }
+ else
+ return this;
+ }
+ }
+
+ class MillsState extends State {
+ int _length;
+ int _value;
+
+ MillsState(State next)
+ {
+ super(next);
+ }
+
+ State next(int ch)
+ {
+ _value = 256 * _value + (ch & 0xff);
+
+ if (++_length == 4) {
+ Double value = 0.001 * _value;
+
+ if (_next.isShift(value))
+ return _next.shift(value);
+ else {
+ printObject(value.toString());
+
+ return _next;
+ }
+ }
+ else
+ return this;
+ }
+ }
+
+ class StringState extends State {
+ private static final int TOP = 0;
+ private static final int UTF_2_1 = 1;
+ private static final int UTF_3_1 = 2;
+ private static final int UTF_3_2 = 3;
+
+ char _typeCode;
+
+ StringBuilder _value = new StringBuilder();
+ int _lengthIndex;
+ int _length;
+ boolean _isLastChunk;
+
+ int _utfState;
+ char _ch;
+
+ StringState(State next, char typeCode, boolean isLastChunk)
+ {
+ super(next);
+
+ _typeCode = typeCode;
+ _isLastChunk = isLastChunk;
+ }
+
+ StringState(State next, char typeCode, int length)
+ {
+ super(next);
+
+ _typeCode = typeCode;
+ _isLastChunk = true;
+ _length = length;
+ _lengthIndex = 2;
+ }
+
+ StringState(State next, char typeCode, int length, boolean isLastChunk)
+ {
+ super(next);
+
+ _typeCode = typeCode;
+ _isLastChunk = isLastChunk;
+ _length = length;
+ _lengthIndex = 1;
+ }
+
+ State next(int ch)
+ {
+ if (_lengthIndex < 2) {
+ _length = 256 * _length + (ch & 0xff);
+
+ if (++_lengthIndex == 2 && _length == 0 && _isLastChunk) {
+ if (_next.isShift(_value.toString()))
+ return _next.shift(_value.toString());
+ else {
+ printObject("\"" + _value + "\"");
+ return _next;
+ }
+ }
+ else
+ return this;
+ }
+ else if (_length == 0) {
+ if (ch == 's' || ch == 'x') {
+ _isLastChunk = false;
+ _lengthIndex = 0;
+ return this;
+ }
+ else if (ch == 'S' || ch == 'X') {
+ _isLastChunk = true;
+ _lengthIndex = 0;
+ return this;
+ }
+ else if (ch == 0x00) {
+ if (_next.isShift(_value.toString()))
+ return _next.shift(_value.toString());
+ else {
+ printObject("\"" + _value + "\"");
+ return _next;
+ }
+ }
+ else if (0x00 <= ch && ch < 0x20) {
+ _isLastChunk = true;
+ _lengthIndex = 2;
+ _length = ch & 0xff;
+ return this;
+ }
+ else if (0x30 <= ch && ch < 0x34) {
+ _isLastChunk = true;
+ _lengthIndex = 1;
+ _length = (ch - 0x30);
+ return this;
+ }
+ else {
+ println(String.valueOf((char) ch) + ": unexpected character");
+ return _next;
+ }
+ }
+
+ switch (_utfState) {
+ case TOP:
+ if (ch < 0x80) {
+ _length--;
+
+ _value.append((char) ch);
+ }
+ else if (ch < 0xe0) {
+ _ch = (char) ((ch & 0x1f) << 6);
+ _utfState = UTF_2_1;
+ }
+ else {
+ _ch = (char) ((ch & 0xf) << 12);
+ _utfState = UTF_3_1;
+ }
+ break;
+
+ case UTF_2_1:
+ case UTF_3_2:
+ _ch += ch & 0x3f;
+ _value.append(_ch);
+ _length--;
+ _utfState = TOP;
+ break;
+
+ case UTF_3_1:
+ _ch += (char) ((ch & 0x3f) << 6);
+ _utfState = UTF_3_2;
+ break;
+ }
+
+ if (_length == 0 && _isLastChunk) {
+ if (_next.isShift(_value.toString()))
+ return _next.shift(_value.toString());
+ else {
+ printObject("\"" + _value + "\"");
+
+ return _next;
+ }
+ }
+ else
+ return this;
+ }
+ }
+
+ class BinaryState extends State {
+ char _typeCode;
+
+ int _totalLength;
+
+ int _lengthIndex;
+ int _length;
+ boolean _isLastChunk;
+
+ BinaryState(State next, char typeCode, boolean isLastChunk)
+ {
+ super(next);
+
+ _typeCode = typeCode;
+ _isLastChunk = isLastChunk;
+ }
+
+ BinaryState(State next, char typeCode, int length)
+ {
+ super(next);
+
+ _typeCode = typeCode;
+ _isLastChunk = true;
+ _length = length;
+ _lengthIndex = 2;
+ }
+
+ BinaryState(State next, char typeCode, int length, boolean isLastChunk)
+ {
+ super(next);
+
+ _typeCode = typeCode;
+ _isLastChunk = isLastChunk;
+ _length = length;
+ _lengthIndex = 1;
+ }
+
+ State next(int ch)
+ {
+ if (_lengthIndex < 2) {
+ _length = 256 * _length + (ch & 0xff);
+
+ if (++_lengthIndex == 2 && _length == 0 && _isLastChunk) {
+ String value = "binary(" + _totalLength + ")";
+
+ if (_next.isShift(value))
+ return _next.shift(value);
+ else {
+ printObject(value);
+ return _next;
+ }
+ }
+ else
+ return this;
+ }
+ else if (_length == 0) {
+ if (ch == 'b') {
+ _isLastChunk = false;
+ _lengthIndex = 0;
+ return this;
+ }
+ else if (ch == 'B') {
+ _isLastChunk = true;
+ _lengthIndex = 0;
+ return this;
+ }
+ else if (ch == 0x20) {
+ String value = "binary(" + _totalLength + ")";
+
+ if (_next.isShift(value))
+ return _next.shift(value);
+ else {
+ printObject(value);
+ return _next;
+ }
+ }
+ else if (0x20 <=ch && ch < 0x30) {
+ _isLastChunk = true;
+ _lengthIndex = 2;
+ _length = (ch & 0xff) - 0x20;
+ return this;
+ }
+ else {
+ println(String.valueOf((char) ch) + ": unexpected character");
+ return _next;
+ }
+ }
+
+ _length--;
+ _totalLength++;
+
+ if (_length == 0 && _isLastChunk) {
+ String value = "binary(" + _totalLength + ")";
+
+ if (_next.isShift(value))
+ return _next.shift(value);
+ else {
+ printObject(value);
+
+ return _next;
+ }
+ }
+ else
+ return this;
+ }
+ }
+
+ class MapState extends State {
+ private static final int TYPE = 0;
+ private static final int KEY = 1;
+ private static final int VALUE = 2;
+
+ private int _refId;
+
+ private int _state;
+ private int _valueDepth;
+ private boolean _hasData;
+
+ MapState(State next, int refId)
+ {
+ super(next);
+
+ _refId = refId;
+ _state = TYPE;
+ }
+
+ MapState(State next, int refId, boolean isType)
+ {
+ super(next);
+
+ _refId = refId;
+
+ if (isType)
+ _state = TYPE;
+ else {
+ printObject("map (#" + _refId + ")");
+ _state = VALUE;
+ }
+ }
+
+ @Override
+ boolean isShift(Object value)
+ {
+ return _state == TYPE;
+ }
+
+ @Override
+ State shift(Object type)
+ {
+ if (_state == TYPE) {
+ if (type instanceof String) {
+ _typeDefList.add((String) type);
+ }
+ else if (type instanceof Integer) {
+ int iValue = (Integer) type;
+
+ if (iValue >= 0 && iValue < _typeDefList.size())
+ type = _typeDefList.get(iValue);
+ }
+
+ printObject("map " + type + " (#" + _refId + ")");
+
+ _state = VALUE;
+
+ return this;
+ }
+ else
+ throw new IllegalStateException();
+ }
+
+ @Override
+ int depth()
+ {
+ if (_state == TYPE)
+ return _next.depth();
+ else if (_state == KEY)
+ return _next.depth() + 2;
+ else
+ return _valueDepth;
+ }
+
+ State next(int ch)
+ {
+ switch (_state) {
+ case TYPE:
+ return nextObject(ch);
+
+ case VALUE:
+ if (ch == 'Z') {
+ if (_hasData)
+ println();
+
+ return _next;
+ }
+ else {
+ if (_hasData)
+ println();
+
+ _hasData = true;
+ _state = KEY;
+
+ return nextObject(ch);
+ }
+
+ case KEY:
+ print(" => ");
+ _isObject = false;
+ _valueDepth = _column;
+
+ _state = VALUE;
+
+ return nextObject(ch);
+
+ default:
+ throw new IllegalStateException();
+ }
+ }
+ }
+
+ class MapState1 extends State1 {
+ private static final int TYPE = 0;
+ private static final int KEY = 1;
+ private static final int VALUE = 2;
+
+ private int _refId;
+
+ private int _state;
+ private int _valueDepth;
+ private boolean _hasData;
+
+ MapState1(State next, int refId)
+ {
+ super(next);
+
+ _refId = refId;
+ _state = TYPE;
+ }
+
+ MapState1(State next, int refId, boolean isType)
+ {
+ super(next);
+
+ _refId = refId;
+
+ if (isType)
+ _state = TYPE;
+ else {
+ printObject("map (#" + _refId + ")");
+ _state = VALUE;
+ }
+ }
+
+ @Override
+ boolean isShift(Object value)
+ {
+ return _state == TYPE;
+ }
+
+ @Override
+ State shift(Object type)
+ {
+ if (_state == TYPE) {
+ if (type instanceof String) {
+ _typeDefList.add((String) type);
+ }
+ else if (type instanceof Integer) {
+ int iValue = (Integer) type;
+
+ if (iValue >= 0 && iValue < _typeDefList.size())
+ type = _typeDefList.get(iValue);
+ }
+
+ printObject("map " + type + " (#" + _refId + ")");
+
+ _state = VALUE;
+
+ return this;
+ }
+ else
+ throw new IllegalStateException();
+ }
+
+ @Override
+ int depth()
+ {
+ if (_state == TYPE)
+ return _next.depth();
+ else if (_state == KEY)
+ return _next.depth() + 2;
+ else
+ return _valueDepth;
+ }
+
+ State next(int ch)
+ {
+ switch (_state) {
+ case TYPE:
+ if (ch == 't') {
+ return new StringState(this, 't', true);
+ }
+ else if (ch == 'z') {
+ println("map (#" + _refId + ")");
+ return _next;
+ }
+ else {
+ println("map (#" + _refId + ")");
+ _hasData = true;
+ _state = KEY;
+ return nextObject(ch);
+ }
+
+ case VALUE:
+ if (ch == 'z') {
+ if (_hasData)
+ println();
+
+ return _next;
+ }
+ else {
+ if (_hasData)
+ println();
+
+ _hasData = true;
+ _state = KEY;
+
+ return nextObject(ch);
+ }
+
+ case KEY:
+ print(" => ");
+ _isObject = false;
+ _valueDepth = _column;
+
+ _state = VALUE;
+
+ return nextObject(ch);
+
+ default:
+ throw new IllegalStateException();
+ }
+ }
+ }
+
+ class ObjectDefState extends State {
+ private static final int TYPE = 1;
+ private static final int COUNT = 2;
+ private static final int FIELD = 3;
+ private static final int COMPLETE = 4;
+
+ private int _refId;
+
+ private int _state;
+ private boolean _hasData;
+ private int _count;
+
+ private String _type;
+ private ArrayList _fields = new ArrayList();
+
+ ObjectDefState(State next)
+ {
+ super(next);
+
+ _state = TYPE;
+ }
+
+ @Override
+ boolean isShift(Object value)
+ {
+ return true;
+ }
+
+ @Override
+ State shift(Object object)
+ {
+ if (_state == TYPE) {
+ _type = (String) object;
+
+ print("/* defun " + _type + " [");
+
+ _objectDefList.add(new ObjectDef(_type, _fields));
+
+ _state = COUNT;
+ }
+ else if (_state == COUNT) {
+ _count = (Integer) object;
+
+ _state = FIELD;
+ }
+ else if (_state == FIELD) {
+ String field = (String) object;
+
+ _count--;
+
+ _fields.add(field);
+
+ if (_fields.size() == 1)
+ print(field);
+ else
+ print(", " + field);
+ }
+ else {
+ throw new UnsupportedOperationException();
+ }
+
+ return this;
+ }
+
+ @Override
+ int depth()
+ {
+ if (_state <= TYPE)
+ return _next.depth();
+ else
+ return _next.depth() + 2;
+ }
+
+ State next(int ch)
+ {
+ switch (_state) {
+ case TYPE:
+ return nextObject(ch);
+
+ case COUNT:
+ return nextObject(ch);
+
+ case FIELD:
+ if (_count == 0) {
+ println("] */");
+ _next.printIndent(0);
+
+ return _next.nextObject(ch);
+ }
+ else
+ return nextObject(ch);
+
+ default:
+ throw new IllegalStateException();
+ }
+ }
+ }
+
+ class ObjectState extends State {
+ private static final int TYPE = 0;
+ private static final int FIELD = 1;
+
+ private int _refId;
+
+ private int _state;
+ private ObjectDef _def;
+ private int _count;
+ private int _fieldDepth;
+
+ ObjectState(State next, int refId)
+ {
+ super(next);
+
+ _refId = refId;
+ _state = TYPE;
+ }
+
+ ObjectState(State next, int refId, int def)
+ {
+ super(next);
+
+ _refId = refId;
+ _state = FIELD;
+
+ if (def < 0 || _objectDefList.size() <= def) {
+ throw new IllegalStateException(def + " is an unknown object type");
+ }
+
+ _def = _objectDefList.get(def);
+
+ println("object " + _def.getType() + " (#" + _refId + ")");
+ }
+
+ @Override
+ boolean isShift(Object value)
+ {
+ if (_state == TYPE)
+ return true;
+ else
+ return false;
+ }
+
+ @Override
+ State shift(Object object)
+ {
+ if (_state == TYPE) {
+ int def = (Integer) object;
+
+ _def = _objectDefList.get(def);
+
+ println("object " + _def.getType() + " (#" + _refId + ")");
+
+ _state = FIELD;
+
+ if (_def.getFields().size() == 0)
+ return _next;
+ }
+
+ return this;
+ }
+
+ @Override
+ int depth()
+ {
+ if (_state <= TYPE)
+ return _next.depth();
+ else
+ return _fieldDepth;
+ }
+
+ State next(int ch)
+ {
+ switch (_state) {
+ case TYPE:
+ return nextObject(ch);
+
+ case FIELD:
+ if (_def.getFields().size() <= _count)
+ return _next.next(ch);
+
+ _fieldDepth = _next.depth() + 2;
+ println();
+ print(_def.getFields().get(_count++) + ": ");
+
+ _fieldDepth = _column;
+
+ _isObject = false;
+ return nextObject(ch);
+
+ default:
+ throw new IllegalStateException();
+ }
+ }
+ }
+
+ class ListState1 extends State1 {
+ private static final int TYPE = 0;
+ private static final int LENGTH = 1;
+ private static final int VALUE = 2;
+
+ private int _refId;
+
+ private int _state;
+ private boolean _hasData;
+ private int _count;
+ private int _valueDepth;
+
+ ListState1(State next, int refId)
+ {
+ super(next);
+
+ _refId = refId;
+
+ _state = TYPE;
+ }
+
+ @Override
+ boolean isShift(Object value)
+ {
+ return _state == TYPE || _state == LENGTH;
+ }
+
+ @Override
+ State shift(Object object)
+ {
+ if (_state == TYPE) {
+ Object type = object;
+
+ if (type instanceof String) {
+ _typeDefList.add((String) type);
+ }
+ else if (object instanceof Integer) {
+ int index = (Integer) object;
+
+ if (index >= 0 && index < _typeDefList.size())
+ type = _typeDefList.get(index);
+ else
+ type = "type-unknown(" + index + ")";
+ }
+
+ printObject("list " + type + "(#" + _refId + ")");
+
+ _state = VALUE;
+
+ return this;
+ }
+ else if (_state == LENGTH) {
+ _state = VALUE;
+
+ return this;
+ }
+ else
+ return this;
+ }
+
+ @Override
+ int depth()
+ {
+ if (_state <= LENGTH)
+ return _next.depth();
+ else if (_state == VALUE)
+ return _valueDepth;
+ else
+ return _next.depth() + 2;
+ }
+
+ State next(int ch)
+ {
+ switch (_state) {
+ case TYPE:
+ if (ch == 'z') {
+ printObject("list (#" + _refId + ")");
+
+ return _next;
+ }
+ else if (ch == 't') {
+ return new StringState(this, 't', true);
+ }
+ else {
+ printObject("list (#" + _refId + ")");
+ printObject(" " + _count++ + ": ");
+ _valueDepth = _column;
+ _isObject = false;
+ _state = VALUE;
+
+ return nextObject(ch);
+ }
+
+ case VALUE:
+ if (ch == 'z') {
+ if (_count > 0)
+ println();
+
+ return _next;
+ }
+ else {
+ _valueDepth = _next.depth() + 2;
+ println();
+ printObject(_count++ + ": ");
+ _valueDepth = _column;
+ _isObject = false;
+
+ return nextObject(ch);
+ }
+
+ default:
+ throw new IllegalStateException();
+ }
+ }
+ }
+
+ class ListState extends State {
+ private static final int TYPE = 0;
+ private static final int LENGTH = 1;
+ private static final int VALUE = 2;
+
+ private int _refId;
+
+ private int _state;
+ private boolean _hasData;
+ private int _count;
+ private int _valueDepth;
+
+ ListState(State next, int refId, boolean isType)
+ {
+ super(next);
+
+ _refId = refId;
+
+ if (isType)
+ _state = TYPE;
+ else {
+ printObject("list (#" + _refId + ")");
+ _state = VALUE;
+ }
+ }
+
+ @Override
+ boolean isShift(Object value)
+ {
+ return _state == TYPE || _state == LENGTH;
+ }
+
+ @Override
+ State shift(Object object)
+ {
+ if (_state == TYPE) {
+ Object type = object;
+
+ if (type instanceof String) {
+ _typeDefList.add((String) type);
+ }
+ else if (object instanceof Integer) {
+ int index = (Integer) object;
+
+ if (index >= 0 && index < _typeDefList.size())
+ type = _typeDefList.get(index);
+ else
+ type = "type-unknown(" + index + ")";
+ }
+
+ printObject("list " + type + "(#" + _refId + ")");
+
+ _state = VALUE;
+
+ return this;
+ }
+ else if (_state == LENGTH) {
+ _state = VALUE;
+
+ return this;
+ }
+ else
+ return this;
+ }
+
+ @Override
+ int depth()
+ {
+ if (_state <= LENGTH)
+ return _next.depth();
+ else if (_state == VALUE)
+ return _valueDepth;
+ else
+ return _next.depth() + 2;
+ }
+
+ State next(int ch)
+ {
+ switch (_state) {
+ case TYPE:
+ return nextObject(ch);
+
+ case VALUE:
+ if (ch == 'Z') {
+ if (_count > 0)
+ println();
+
+ return _next;
+ }
+ else {
+ _valueDepth = _next.depth() + 2;
+ println();
+ printObject(_count++ + ": ");
+ _valueDepth = _column;
+ _isObject = false;
+
+ return nextObject(ch);
+ }
+
+ default:
+ throw new IllegalStateException();
+ }
+ }
+ }
+
+ class CompactListState extends State {
+ private static final int TYPE = 0;
+ private static final int LENGTH = 1;
+ private static final int VALUE = 2;
+
+ private int _refId;
+
+ private boolean _isTyped;
+ private boolean _isLength;
+
+ private int _state;
+ private boolean _hasData;
+ private int _length;
+ private int _count;
+ private int _valueDepth;
+
+ CompactListState(State next, int refId, boolean isTyped)
+ {
+ super(next);
+
+ _isTyped = isTyped;
+ _refId = refId;
+
+ if (isTyped)
+ _state = TYPE;
+ else
+ _state = LENGTH;
+ }
+
+ CompactListState(State next, int refId, boolean isTyped, int length)
+ {
+ super(next);
+
+ _isTyped = isTyped;
+ _refId = refId;
+ _length = length;
+
+ _isLength = true;
+
+ if (isTyped)
+ _state = TYPE;
+ else {
+ printObject("list (#" + _refId + ")");
+
+ _state = VALUE;
+ }
+ }
+
+ @Override
+ boolean isShift(Object value)
+ {
+ return _state == TYPE || _state == LENGTH;
+ }
+
+ @Override
+ State shift(Object object)
+ {
+ if (_state == TYPE) {
+ Object type = object;
+
+ if (object instanceof Integer) {
+ int index = (Integer) object;
+
+ if (index >= 0 && index < _typeDefList.size())
+ type = _typeDefList.get(index);
+ else
+ type = "type-unknown(" + index + ")";
+ }
+ else if (object instanceof String)
+ _typeDefList.add((String) object);
+
+ printObject("list " + type + " (#" + _refId + ")");
+
+ if (_isLength) {
+ _state = VALUE;
+
+ if (_length == 0)
+ return _next;
+ }
+ else
+ _state = LENGTH;
+
+ return this;
+ }
+ else if (_state == LENGTH) {
+ _length = (Integer) object;
+
+ if (! _isTyped)
+ printObject("list (#" + _refId + ")");
+
+ _state = VALUE;
+
+ if (_length == 0)
+ return _next;
+ else
+ return this;
+ }
+ else
+ return this;
+ }
+
+ @Override
+ int depth()
+ {
+ if (_state <= LENGTH)
+ return _next.depth();
+ else if (_state == VALUE)
+ return _valueDepth;
+ else
+ return _next.depth() + 2;
+ }
+
+ State next(int ch)
+ {
+ switch (_state) {
+ case TYPE:
+ return nextObject(ch);
+
+ case LENGTH:
+ return nextObject(ch);
+
+ case VALUE:
+ if (_length <= _count)
+ return _next.next(ch);
+ else {
+ _valueDepth = _next.depth() + 2;
+ println();
+ printObject(_count++ + ": ");
+ _valueDepth = _column;
+ _isObject = false;
+
+ return nextObject(ch);
+ }
+
+ default:
+ throw new IllegalStateException();
+ }
+ }
+ }
+
+ class Hessian2State extends State {
+ private static final int MAJOR = 0;
+ private static final int MINOR = 1;
+
+ private int _state;
+ private int _major;
+ private int _minor;
+
+ Hessian2State(State next)
+ {
+ super(next);
+ }
+
+ int depth()
+ {
+ return _next.depth() + 2;
+ }
+
+ State next(int ch)
+ {
+ switch (_state) {
+ case MAJOR:
+ _major = ch;
+ _state = MINOR;
+ return this;
+
+ case MINOR:
+ _minor = ch;
+ println(-2, "Hessian " + _major + "." + _minor);
+ return _next;
+
+ default:
+ throw new IllegalStateException();
+ }
+ }
+ }
+
+ class CallState1 extends State1 {
+ private static final int MAJOR = 0;
+ private static final int MINOR = 1;
+ private static final int HEADER = 2;
+ private static final int METHOD = 3;
+ private static final int VALUE = 4;
+ private static final int ARG = 5;
+
+ private int _state;
+ private int _major;
+ private int _minor;
+
+ CallState1(State next)
+ {
+ super(next);
+ }
+
+ int depth()
+ {
+ return _next.depth() + 2;
+ }
+
+ State next(int ch)
+ {
+ switch (_state) {
+ case MAJOR:
+ _major = ch;
+ _state = MINOR;
+ return this;
+
+ case MINOR:
+ _minor = ch;
+ _state = HEADER;
+ println(-2, "call " + _major + "." + _minor);
+ return this;
+
+ case HEADER:
+ if (ch == 'H') {
+ println();
+ print("header ");
+ _isObject = false;
+ _state = VALUE;
+ return new StringState(this, 'H', true);
+ }
+ else if (ch == 'm') {
+ println();
+ print("method ");
+ _isObject = false;
+ _state = ARG;
+ return new StringState(this, 'm', true);
+ }
+ else {
+ println((char) ch + ": unexpected char");
+ return popStack();
+ }
+
+ case VALUE:
+ print(" => ");
+ _isObject = false;
+ _state = HEADER;
+ return nextObject(ch);
+
+ case ARG:
+ if (ch == 'z') {
+ println();
+ return _next;
+ }
+ else
+ return nextObject(ch);
+
+ default:
+ throw new IllegalStateException();
+ }
+ }
+ }
+
+ class Call2State extends State {
+ private static final int METHOD = 0;
+ private static final int COUNT = 1;
+ private static final int ARG = 2;
+
+ private int _state = METHOD;
+ private int _i;
+ private int _count;
+
+ Call2State(State next)
+ {
+ super(next);
+ }
+
+ int depth()
+ {
+ return _next.depth() + 5;
+ }
+
+ @Override
+ boolean isShift(Object value)
+ {
+ return _state != ARG;
+ }
+
+ @Override
+ State shift(Object object)
+ {
+ if (_state == METHOD) {
+ println(-5, "Call " + object);
+
+ _state = COUNT;
+ return this;
+ }
+ else if (_state == COUNT) {
+ Integer count = (Integer) object;
+
+ _count = count;
+
+ _state = ARG;
+
+ if (_count == 0) {
+ return _next;
+ }
+ else
+ return this;
+ }
+ else {
+ return this;
+ }
+ }
+
+ @Override
+ State next(int ch)
+ {
+ switch (_state) {
+ case COUNT:
+ return nextObject(ch);
+
+ case METHOD:
+ return nextObject(ch);
+
+ case ARG:
+ if (_count <= _i) {
+ println();
+ return _next.next(ch);
+ }
+ else {
+ println();
+ print(-3, _i++ + ": ");
+
+ return nextObject(ch);
+ }
+
+ default:
+ throw new IllegalStateException();
+ }
+ }
+ }
+
+ class ReplyState1 extends State1 {
+ private static final int MAJOR = 0;
+ private static final int MINOR = 1;
+ private static final int HEADER = 2;
+ private static final int VALUE = 3;
+ private static final int END = 4;
+
+ private int _state;
+ private int _major;
+ private int _minor;
+
+ ReplyState1(State next)
+ {
+ _next = next;
+ }
+
+ int depth()
+ {
+ return _next.depth() + 2;
+ }
+
+ State next(int ch)
+ {
+ switch (_state) {
+ case MAJOR:
+ if (ch == 't' || ch == 'S')
+ return new RemoteState(this).next(ch);
+
+ _major = ch;
+ _state = MINOR;
+ return this;
+
+ case MINOR:
+ _minor = ch;
+ _state = HEADER;
+ println(-2, "reply " + _major + "." + _minor);
+ return this;
+
+ case HEADER:
+ if (ch == 'H') {
+ _state = VALUE;
+ return new StringState(this, 'H', true);
+ }
+ else if (ch == 'f') {
+ print("fault ");
+ _isObject = false;
+ _state = END;
+ return new MapState(this, 0);
+ }
+ else {
+ _state = END;
+ return nextObject(ch);
+ }
+
+ case VALUE:
+ _state = HEADER;
+ return nextObject(ch);
+
+ case END:
+ println();
+ if (ch == 'z') {
+ return _next;
+ }
+ else
+ return _next.next(ch);
+
+ default:
+ throw new IllegalStateException();
+ }
+ }
+ }
+
+ class Reply2State extends State {
+ Reply2State(State next)
+ {
+ super(next);
+
+ println(-2, "Reply");
+ }
+
+ int depth()
+ {
+ return _next.depth() + 2;
+ }
+
+ @Override
+ State next(int ch)
+ {
+ if (ch < 0) {
+ println();
+ return _next;
+ }
+ else {
+ return nextObject(ch);
+ }
+ }
+ }
+
+ class Fault2State extends State {
+ Fault2State(State next)
+ {
+ super(next);
+
+ println(-2, "Fault");
+ }
+
+ int depth()
+ {
+ return _next.depth() + 2;
+ }
+
+ @Override
+ State next(int ch)
+ {
+ return nextObject(ch);
+ }
+ }
+
+ class IndirectState extends State {
+ IndirectState(State next)
+ {
+ super(next);
+ }
+
+ boolean isShift(Object object)
+ {
+ return _next.isShift(object);
+ }
+
+ State shift(Object object)
+ {
+ return _next.shift(object);
+ }
+
+ State next(int ch)
+ {
+ return nextObject(ch);
+ }
+ }
+
+ class RemoteState extends State {
+ private static final int TYPE = 0;
+ private static final int VALUE = 1;
+ private static final int END = 2;
+
+ private int _state;
+ private int _major;
+ private int _minor;
+
+ RemoteState(State next)
+ {
+ super(next);
+ }
+
+ State next(int ch)
+ {
+ switch (_state) {
+ case TYPE:
+ println(-1, "remote");
+ if (ch == 't') {
+ _state = VALUE;
+ return new StringState(this, 't', false);
+ }
+ else {
+ _state = END;
+ return nextObject(ch);
+ }
+
+ case VALUE:
+ _state = END;
+ return _next.nextObject(ch);
+
+ case END:
+ return _next.next(ch);
+
+ default:
+ throw new IllegalStateException();
+ }
+ }
+ }
+
+ class StreamingState extends State {
+ private int _digit;
+ private int _code;
+ private int _length;
+ private boolean _isLast;
+ private boolean _isFirst = true;
+
+ private State _childState;
+
+ StreamingState(State next, boolean isLast)
+ {
+ super(next);
+
+ _isLast = isLast;
+ _childState = new InitialState();
+ }
+
+ State next(int ch)
+ {
+ if (_digit >= 0) {
+ if (_digit == 0) {
+ _code = ch;
+ _digit = 1;
+ _length = 0;
+
+ return this;
+ }
+ else if ((ch & 0x80) == 0x80) {
+ _length = 128 * _length + (ch & 0x7f);
+
+ return this;
+ }
+ else {
+ _length = 128 * _length + (ch & 0x7f);
+ _digit = -1;
+ }
+
+ if (_isFirst)
+ println(-1, "packet-start(" + _length + ")");
+ _isFirst = false;
+
+ if (_length == 0) {
+ _isFirst = true;
+ println(-1, "");
+ println(-1, "packet-end");
+ _refId = 0;
+ _digit = 0;
+ }
+
+ return this;
+ }
+ else if (_length == 0) {
+ _digit = 0;
+
+ return this;
+ }
+
+ _childState = _childState.next(ch);
+
+ _length--;
+
+ if (_length <= 0) {
+ _digit = 0;
+ _length = 0;
+ return this;
+ }
+ else
+ return this;
+ }
+ }
+
+ static class ObjectDef {
+ private String _type;
+ private ArrayList