/ - Diff - Java object universal deserializer (GK Software) - Horký - Redmine

     <classpath>
     	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-11"/>
     	<classpathentry kind="src" path="src"/>
     	<classpathentry excluding="src/" kind="src" path=""/>
     	<classpathentry kind="output" path="bin"/>
         <classpathentry exported="true" kind="lib" path="lib/jackson-core-asl-1.9.13.jar"/>
         <classpathentry exported="true" kind="lib" path="lib/jackson-mapper-asl-1.9.13.jar"/>
             <classpathentry exported="true" kind="lib" path="lib/jackson-core-asl-1.9.13.jar"/>
             <classpathentry exported="true" kind="lib" path="lib/jackson-mapper-asl-1.9.13.jar"/>
             <classpathentry exported="true" kind="lib" path="lib/jdeserialize-1.2.jar"/>
     </classpath>

     JACKSON JSON
     This copy of Jackson JSON processor streaming parser/generator is licensed under the
     Apache (Software) License, version 2.0 ("the License").
     See the License for details about distribution rights, and the
     specific rights regarding derivate works.
     You may obtain a copy of the License at:
     http://www.apache.org/licenses/LICENSE-2.0
     ************************************************************
     JDESERIALIZE
     https://code.google.com/archive/p/jdeserialize/
     https://opensource.org/licenses/BSD-3-Clause
     Copyright <YEAR> <COPYRIGHT HOLDER>
     Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
 . Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
 . 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.
 . Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS 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 THE COPYRIGHT HOLDER OR 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.

     import java.io.ObjectOutputStream;
     import java.util.ArrayList;
     import java.util.List;
     import jdeserialize.Getopt;
     import jdeserialize.classdesc;
     import jdeserialize.content;
     import jdeserialize.instance;
     import jdeserialize.jdeserialize;
     import org.codehaus.jackson.map.ObjectMapper;
     import org.codehaus.jackson.map.ObjectWriter;
     import org.unsynchronized.jdeserialize;
     public class App {
         /**
          * When the Serialized and deserialized classes are same, but placed in diff packages, the
          * deserialization does not work. When they are
+         *
          * !CAREFUL! For testing purposes the somehow standartized package path (org.blah.etc...)
          * is not followed. Repair in the future - because of used libs.
+         *
          * jdeserializer also as .jar module!
          **/
         public static void main(String[] args) throws Exception {
             App app = new App();
-...
             //app.jdCallMain();
             // test directly through code call
             app.jdCallLib("serialized/simple.out");
             app.jdCallLib("serialized/simple.out", true, "deserializedResults/simple.json");
             System.out.println("Vše OK, díky.");
+        }
         /**
-...
+         *
          * SHOULD NOT BE HERE
          * **/
         private void jdCallLib(String filename)
         private void jdCallLib(String filename, boolean dump, String outputFileJSON)
+        {
             try
+            {
-...
                 //testing with only first of the contents
                 String json = objectToJSON(cntnts.get(0));
                 if(dump)
+                {
                     System.out.println(json);
+                }
                 if(outputFileJSON != null && !outputFileJSON.isEmpty())
+                {
                     File toWrite = new File(outputFileJSON);
                     toWrite.createNewFile();
                     FileOutputStream fos = new FileOutputStream(toWrite, false);
                     ObjectOutputStream oos = new ObjectOutputStream(fos);
                     oos.writeObject(json);
                     oos.flush();
                     oos.close();
                     System.out.println("Soubor " + outputFileJSON + " s deserializovaným objektem vytvořen.");
+                }
                 int c = 0;
+            }
             catch (IOException e)
+            {
-...
         private String objectToJSON(Object in)
+        {
             ObjectWriter ow = new ObjectMapper().writer().withDefaultPrettyPrinter();
             String json = ow.writeValueAsString(in);
             String json = "";
             try
+            {
                 json = ow.writeValueAsString(in);
+            }
             catch (IOException e)
+            {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
+            }
             return json;
+        }

     package jdeserialize;
     import java.io.*;
     import java.util.*;
     /**
      * Exception used to signal that an exception object was successfully read from the
      * stream.  This object holds a reference to the serialized exception object.
      */
     public class ExceptionReadException extends IOException {
         public static final long serialVersionUID = 2277356908919221L;
         public content exceptionobj;
         /**
          * Constructor.
          * @param c the serialized exception object that was read
          */
         public ExceptionReadException(content c) {
             super("serialized exception read during stream");
             this.exceptionobj = c;
+        }
         /**
          * Gets the Exception object that was thrown.
          * @return the content representing the serialized exception object
          */
         public content getExceptionObject() {
             return exceptionobj;
+        }
+    }

     package jdeserialize;
     import java.io.*;
     import java.util.*;
     /**
      * Simple getopt()-like implementation.
      */
     public class Getopt {
         private Map<String, Integer> options;
         private List<String> otherargs;
         private Map<String, String> descriptions;
         private Map<String, List<String>> optvals;
         public class OptionParseException extends Exception {
             public static final long serialVersionUID = 2898924890585885551L;
             public OptionParseException(String message) {
                 super(message);
+            }
+        }
         /**
          * Gets the list arguments specified that were *not* options or their arguments, in
          * the order they were specified.
+         *
          * @return the list of non-option String arguments
          */
         public List<String> getOtherArguments() {
             return otherargs;
+        }
         /**
          * Gets the set of all options specified, as well as the list of their arguments.
+         *
          * @return a map of all options specified; values are lists of arguments
          */
         public Map<String, List<String>> getOptionValues() {
             return optvals;
+        }
         /**
          * Constructor.
+         *
          * @param options Map of options to parse.  The key should be an option string (including
          * any initial dashes), and the value should be an Integer representing the number of
          * arguments to parse following the option.
          * @param descriptions Map of option descriptions.
          */
         public Getopt(Map<String, Integer> options, Map<String, String> descriptions) {
             this.options = options;
             this.descriptions = descriptions;
+        }
         /**
          * Constructor.
          */
         public Getopt() {
             this.options = new HashMap<String, Integer>();
             this.descriptions = new HashMap<String, String>();
+        }
         /**
          * Determines whether or not the option was specified when the arguments were parsed.
+         *
          * @return true iff the argument was specified (with the correct number of arguments).
          */
         public boolean hasOption(String opt) {
             return optvals.containsKey(opt);
+        }
         /**
          * Gets the list of arguments for a given option, or null if the option wasn't
          * specified.
+         *
          * @param option the option
          * @return the list of arguments for option
          */
         public List<String> getArguments(String option) {
             return optvals.get(option);
+        }
         /**
          * Add an option to the internal set, including the number of arguments and the
          * description.
+         *
          * @param option option string, including any leading dashes
          * @param arguments number of arguments
          * @param description description of the option
          */
         public void addOption(String option, int arguments, String description) {
             options.put(option, arguments);
             descriptions.put(option, description);
+        }
         /**
          * Do the parsing/validation.
          * @param args arguments to parse
          * @throws OptionParseException if a parse error occurs (the exception message will
          * have details)
          */
         public void parse(String[] args) throws OptionParseException {
             this.otherargs = new ArrayList<String>();
             this.optvals = new HashMap<String, List<String>>();
             for(int i = 0; i < args.length; i++) {
                 if(optvals != null) {
                     Integer count = options.get(args[i]);
                     if(count != null) {
                         ArrayList<String> al = new ArrayList<String>(count.intValue());
                         for(int j = 0; j < count; j++) {
                             if(i+1+j >= args.length) {
                                 throw new OptionParseException("expected " + count + " arguments after " + args[i]);
+                            }
                             al.add(args[i+1+j]);
+                        }
                         List<String> oldal = optvals.get(args[i]);
                         if(oldal == null) {
                             optvals.put(args[i], al);
                         } else {
                             oldal.addAll(al);
+                        }
                         i += count;
                         continue;
+                    }
+                }
                 otherargs.add(args[i]);
+            }
+        }
         /**
          * Get a tabular description of all options and their descriptions, one per line.
          */
         public String getDescriptionString() {
             String linesep = System.getProperty("line.separator");
             StringBuffer sb = new StringBuffer();
             if(options != null && options.size() > 0) {
                 sb.append("Options:").append(linesep);
                 TreeSet<String> opts = new TreeSet<String>(this.options.keySet());
                 for(String opt: opts) {
                     sb.append("    ").append(opt);
                     for(int i = 0; i < options.get(opt); i++) {
                         sb.append(" arg").append(i+1);
+                    }
                     sb.append(": ").append(descriptions.get(opt)).append(linesep);
+                }
+            }
             return sb.toString();
+        }
         public static void main(String[] args) {
             try {
                 HashMap<String, Integer> options = new HashMap<String, Integer>();
                 Getopt go = new Getopt();
                 go.addOption("-optzero", 0, "zero-arg constructor");
                 go.addOption("-optone", 1, "one-arg constructor");
                 go.addOption("-opttwo", 2, "two-arg constructor");
                 go.parse(args);
                 System.out.println(go.getDescriptionString());
                 System.out.println("options:");
                 Map<String, List<String>> optvals = go.getOptionValues();
                 for(String opt: optvals.keySet()) {
                     System.out.print("    " + opt);
                     for(String optval: optvals.get(opt)) {
                         System.out.print(" " + optval);
+                    }
                     System.out.println("");
+                }
                 System.out.println("");
                 System.out.println("otherargs:");
                 for(String arg: go.getOtherArguments()) {
                     System.out.println("    " + arg);
+                }
             } catch (Throwable t) {
                 t.printStackTrace();
+            }
+        }
+    }

     package jdeserialize;
     import java.io.*;
     import java.util.*;
     /**
      * <p>
      * An InputStream designed to record data passing through the stream after a call to
      * record() is made.  After record() is called, the results from every read will
      * be stored in an * internal buffer.  The contents of the buffer can be
      * retrieved by getRecordedData(); to stop recording and clear the internal
      * buffer, call stopRecording().
      * </p>
+     *
      * <p>
      * <b>Note</b>: calls to mark() and reset() are merely passed through to the inner stream; if
      * recording is active, the buffer won't be backtracked by reset().
      * </p>
      */
     public class LoggerInputStream extends InputStream {
         private InputStream innerStream = null;
         private ByteArrayOutputStream baos = null;
         private boolean recording = false;
         public LoggerInputStream(InputStream innerStream) {
             super();
             this.innerStream = innerStream;
+        }
         public synchronized int read() throws IOException {
             int i = innerStream.read();
             if(recording && i != -1) {
                 if(i > 255 || i < 0) {
                     throw new IOException("non-byte, non--1 value read from inner stream: " + i);
+                }
                 baos.write((byte)i);
+            }
             return i;
+        }
         public synchronized int read(byte[] b) throws IOException {
             return this.read(b, 0, b.length);
+        }
         public synchronized int read(byte[] b, int off, int len) throws IOException {
             int retval = innerStream.read(b, off, len);
             if(recording && retval > 0) {
                 if(retval > len) {
                     throw new IOException("inner stream read(byte[], int, int) violating contract; return value > len: " + retval);
+                }
                 baos.write(b, off, retval);
+            }
             return retval;
+        }
         public synchronized long skip(long n) throws IOException {
             if(n < 0) {
                 throw new IOException("can't skip negative number of bytes");
+            }
             if(recording == false) {
                 return innerStream.skip(n);
+            }
             long nskipped = 0;
             while(n > Integer.MAX_VALUE) {
                 long ret = skip(Integer.MAX_VALUE);
                 nskipped += ret;
                 if(ret < Integer.MAX_VALUE) {
                     return nskipped;
+                }
                 n -= ret;
+            }
             int toread = (int)n, actuallyread = 0;
             byte[] buf = new byte[10240];
             while(toread > 0) {
                 int r = Math.min(toread, buf.length);
                 int rret = this.read(buf, 0, r);
                 actuallyread += rret;
                 toread -= rret;
                 if(rret < r) {
                     break;
+                }
+            }
             return actuallyread;
+        }
         public synchronized int available() throws IOException {
             return innerStream.available();
+        }
         public synchronized void close() throws IOException {
             innerStream.close();
+        }
         public synchronized void mark(int readlimit) {
             innerStream.mark(readlimit);
+        }
         public synchronized void reset() throws IOException {
             innerStream.reset();
+        }
         public boolean markSupported() {
             return innerStream.markSupported();
+        }
         /**
          * If not currently recording, start recording.  If the stream is currently recording,
          * the current buffer is cleared.
          */
         public synchronized void record() {
             recording = true;
             baos = new ByteArrayOutputStream();
+        }
         /**
          * Stops recording and clears the internal buffer.  If recording is not active, an
          * IOException is thrown.
+         *
          * @throws IOException if recording is not currently active
          */
         public synchronized void stopRecording() throws IOException {
             if(recording == false) {
                 throw new IOException("recording not active");
+            }
             try {
                 baos.close();
             } catch (IOException ignore) {}
             baos = null;
             recording = false;
+        }
         /**
          * Returns the data recorded so far; if recording is not active, an empty buffer
          * is returned.
          */
         public synchronized byte[] getRecordedData() {
             if(recording == false) {
                 return new byte[0];
+            }
             return baos.toByteArray();
+        }
+    }

     package jdeserialize;
     import java.io.*;
     import java.util.*;
     /**
      * Exception that denotes that data in the stream did not conform to the constraints
      * imposed by the specification.
      */
     public class ValidityException extends IOException {
         public static final long serialVersionUID = 2277356908919241L;
         public ValidityException(String msg) {
             super(msg);
+        }
+    }

     package jdeserialize;
     import java.io.*;
     import java.util.*;
     /**
      * <p>Typed collection used for storing the values of a serialized array.  </p>
+     *
      * <p>Primitive types are stored using their corresponding objects; for instance, an int is
      * stored as an Integer.  To determine whether or not this is an array of ints or of
      * Integer instances, check the name in the arrayobj's class description.</p>
      */
     public class arraycoll extends ArrayList<Object> {
         public static final long serialVersionUID = 2277356908919248L;
         private fieldtype ftype;
         /**
          * Constructor.
          * @param ft field type of the array
          */
         public arraycoll(fieldtype ft) {
             super();
             this.ftype = ft;
+        }
         /**
          * Gets the field type of the array.
+         *
          * @return the field type of the array
          */
         public fieldtype getFieldType() {
             return ftype;
+        }
         public String toString() {
             StringBuffer sb = new StringBuffer();
             sb.append("[arraycoll sz ").append(this.size());
             boolean first = true;
             for(Object o: this) {
                 if(first) {
                     first = false;
                     sb.append(' ');
                 } else {
                     sb.append(", ");
+                }
                 sb.append(o.toString());
+            }
             return sb.toString();
+        }
+    }

     package jdeserialize;
     import java.io.*;
     import java.util.*;
     /**
      * <p>Represents an array instance, including the values the comprise the array.  </p>
+     *
      * <p>Note that in arrays of primitives, the classdesc will be named "[x", where x is the
      * field type code representing the primitive type.  See jdeserialize.resolveJavaType()
      * for an example of analysis/generation of human-readable names from these class names.</p>
      */
     public class arrayobj extends contentbase {
         /**
          * Type of the array instance.
          */
         public classdesc classdesc;
         /**
          * Values of the array, in the order they were read from the stream.
          */
         public arraycoll data;
         public arrayobj(int handle, classdesc cd, arraycoll data) {
             super(contenttype.ARRAY);
             this.handle = handle;
             this.classdesc = cd;
             this.data = data;
+        }
         public String toString() {
             return "[array " + jdeserialize.hex(handle) + " classdesc " + classdesc.toString() + ": "
                 + data.toString() + "]";
+        }
+    }

     package jdeserialize;
     import java.io.*;
     /**
      * Represents an opaque block of data written to the stream.  Primarily, these are used to
      * write class and object annotations by ObjectOutputStream overrides; they can also occur
      * inside an object, when the object overrides Serializable.writeObject().  Their
      * interpretation is hereby left to users.
      */
     public class blockdata extends contentbase {
         /**
          * The block data read from the stream.
          */
         public byte[] buf;
         /**
          * Constructor.
+         *
          * @param buf the block data
          */
         public blockdata(byte[] buf) {
             super(contenttype.BLOCKDATA);
             this.buf = buf;
+        }
         public String toString() {
             return "[blockdata " + jdeserialize.hex(handle) + ": " + buf.length + " bytes]";
+        }
+    }

     package jdeserialize;
     import java.io.*;
     import java.util.*;
     /**
      * <p>
      * Represents the entire serialized prototype of the class, including all fields,
      * inner classes, class annotations, and inheritance hierarchy.  This includes proxy class
      * descriptions.
      * </p>
+     *
      * <p>
      * Generally, this class is used to represent the type of an instance written to an
      * ObjectOutputStream with its writeObject() method, or of a related array or field type.
      * However, there's a notable exception: when instances of type java.io.ObjectStreamClass
      * are written with writeObject(), only their class description is written (cf. Object
      * Serialization Specification, 4.3).  They will be represented with an instance of
      * classdesc as well.
      * </p>
      */
     public class classdesc extends contentbase {
         /**
          * Type of the class being represented; either a normal class or a proxy class.
          */
         public classdesctype classtype;
         /**
          * Class name.
          */
         public String name;
         /**
          * Serial version UID, as recorded in the stream.
          */
         public long serialVersionUID;
         /**
          * Description flags byte; this should be a mask of values from the ObjectStreamContants
          * class.  Refer to chapter 6 of the Object Stream Serialization Protocol for details.
          */
         public byte descflags;
         /**
          * Array of fields in the class, in the order serialized by the stream writer.
          */
         public field[] fields;
         /**
          * List of inner classes, in the order serialized by the stream writer.
          */
         public List<classdesc> innerclasses;
         /**
          * List of annotation objects; these are *not* Java annotations, but data written by
          * the <pre>annotateClass(Class<?>)<pre> and <pre>annotateProxyClass(Class<?>)</pre> methods of an
          * ObjectOutputStream.
          */
         public List<content> annotations;
         /**
          * The superclass of the object, if available.
          */
         public classdesc superclass;
         /**
          * Array of serialized interfaces, in the order serialized by the stream writer.
          */
         public String[] interfaces;
         /**
          * Set of enum constants, for enum classes.
          */
         public Set<String> enumconstants;
         private boolean isInnerClass = false;
         /**
          * True if this class has been determined to be an inner class; this determination is
          * generally made by connectMemberClasses().
+         *
          * @return true if the class is an inner class
          */
         public boolean isInnerClass() {
             return isInnerClass;
+        }
         /**
          * Sets the value that denotes that the class is an inner class.
+         *
          * @param nis the value to set
          */
         public void setIsInnerClass(boolean nis) {
             this.isInnerClass = nis;
+        }
         private boolean isLocalInnerClass = false;
         /**
          * True if this class has been determined to be a local inner class; this
          * determination is generally made by connectMemberClasses().
+         *
          * @return true if the class is a local inner class
          */
         public boolean isLocalInnerClass() {
             return isLocalInnerClass;
+        }
         /**
          * Sets the flag that denotes whether this class is a local inner class.
+         *
          * @param nis the value to set
          */
         public void setIsLocalInnerClass(boolean nis) {
             this.isLocalInnerClass = nis;
+        }
         private boolean isStaticMemberClass = false;
         /**
          * <p>
          * True if this class has been determined to be a static member class; this
          * determination is generally made by connectMemberClasses().
          * </p>
+         *
          * <p>
          * Note that in some cases, static member classes' descriptions will be serialized
          * even though their enclosing class is not.  In these cases, this may return false.
          * See connectMemberClasses() for details.
          * </p>
+         *
          * @return true if this is a static member class
          */
         public boolean isStaticMemberClass() {
             return isStaticMemberClass;
+        }
         /**
          * Sets the flag that denotes whether this class is a static member class.
+         *
          * @param nis the value to set
          */
         public void setIsStaticMemberClass(boolean nis) {
             this.isStaticMemberClass = nis;
+        }
         /**
          * Constructor.
+         *
          * @param classtype the type of the class
          */
         public classdesc(classdesctype classtype) {
             super(contenttype.CLASSDESC);
             this.classtype = classtype;
             this.enumconstants = new HashSet<String>();
             this.innerclasses = new ArrayList<classdesc>();
+        }
         /**
          * Add an inner class to the description's list.
          * @param cd inner class to add
          */
         public void addInnerClass(classdesc cd) {
             innerclasses.add(cd);
+        }
         /**
          * Add an enum constant to the description's set.
+         *
          * @param constval enum constant string
          */
         public void addEnum(String constval) {
             this.enumconstants.add(constval);
+        }
         /**
          * Determines whether this is an array type.
          * @return true if this is an array type.
          */
         public boolean isArrayClass() {
             if(name != null && name.length() > 1 && name.charAt(0) == '[') {
                 return true;
             } else {
                 return false;
+            }
+        }
         public String toString() {
             StringBuffer sb = new StringBuffer();
             sb.append("[cd ").append(jdeserialize.hex(handle)).append(": name ").append(name);
             sb.append(" uid ").append(serialVersionUID);
             sb.append("]");
             return sb.toString();
+        }
         /**
          * Generates a list of all class descriptions in this class's hierarchy, in the order
          * described by the Object Stream Serialization Protocol.  This is the order in which
          * fields are read from the stream.
+         *
          * @param classes a list to be filled in with the hierarchy
          */
         public void getHierarchy(ArrayList<classdesc> classes) {
             if(superclass != null) {
                 if(superclass.classtype == classdesctype.PROXYCLASS) {
                     jdeserialize.debugerr("warning: hit a proxy class in superclass hierarchy");
                 } else {
                     superclass.getHierarchy(classes);
+                }
+            }
             classes.add(this);
+        }
         public void validate() throws ValidityException {
             // If neither SC_SERIALIZABLE nor SC_EXTERNALIZABLE is set, then the number of
             // fields is always zero.  (spec section 4.3)
             if((descflags & (ObjectStreamConstants.SC_SERIALIZABLE | ObjectStreamConstants.SC_EXTERNALIZABLE)) == 0 && fields != null && fields.length > 0) {
                 throw new ValidityException("non-serializable, non-externalizable class has fields!");
+            }
             if((descflags & (ObjectStreamConstants.SC_SERIALIZABLE | ObjectStreamConstants.SC_EXTERNALIZABLE)) == (ObjectStreamConstants.SC_SERIALIZABLE | ObjectStreamConstants.SC_EXTERNALIZABLE)) {
                 throw new ValidityException("both Serializable and Externalizable are set!");
+            }
             if((descflags & ObjectStreamConstants.SC_ENUM) != 0) {
                 // we're an enum; shouldn't have any fields/superinterfaces
                 if((fields != null && fields.length > 0) || interfaces != null) {
                     throw new ValidityException("enums shouldn't implement interfaces or have non-constant fields!");
+                }
             } else {
                 // non-enums shouldn't have enum constant fields.
                 if(enumconstants != null && enumconstants.size() > 0) {
                     throw new ValidityException("non-enum classes shouldn't have enum constants!");
+                }
+            }
+        }
+    }

     package jdeserialize;
     /**
      * Enum for class description types.
      */
     public enum classdesctype {
         NORMALCLASS, PROXYCLASS
+    }

     package jdeserialize;
     import java.io.*;
     import java.util.*;
     /**
      * This represents a Class object (i.e. an instance of type Class) serialized in the
      * stream.
      */
     public class classobj extends contentbase {
         /**
          * The class description, including its name.
          */
         public classdesc classdesc;
         /**
          * Constructor.
+         *
          * @param handle the instance's handle
          * @param cd the instance's class description
          */
         public classobj(int handle, classdesc cd) {
             super(contenttype.CLASS);
             this.handle = handle;
             this.classdesc = cd;
+        }
         public String toString() {
             return "[class " + jdeserialize.hex(handle) + ": " + classdesc.toString() + "]";
+        }
+    }

     package jdeserialize;
     import java.io.*;
     import java.util.*;
     /**
      * <p>
      * Generic interface for all data that may be read from the stream (except null).
      * </p>
+     *
      * <p>
      * A successful read of the stream will result in a series of content instances or null
      * references.  For details on specific metadata, see documentation on implementing
      * classes/subinterfaces.
      * </p>
      */
     public interface content {
         /**
          * @return the type of instance represented by this object.
          */
         public contenttype getType();
         /**
          * <p>
          * Get the numeric handle by which this object was referred to in the object stream.
          * These handles are used internally by Object{Output,Input}Stream as a mechanism to
          * avoid costly duplication.
          * </p>
+         *
          * <p>
          * CAUTION: they are *not* necessarily unique across all objects in a given stream!
          * If an exception was thrown during serialization (which is most likely to happen
          * during a serialized objct's writeObject() implementation), then the stream resets
          * before and after the exception is serialized.
          * </p>
+         *
          * @return the handle assigned in the stream
          */
         public int getHandle();
         /**
          * Performs extra object-specific validity checks.
+         *
          * @throws ValidityException if the object's state is invalid
          */
         public void validate() throws ValidityException;
         /**
          * <p>
          * Tells whether or not this object is an exception that was caught during
          * serialization.
          * </p>
+         *
          * <p>
          * <b>Note</b>:  Not every Throwable or Exception in the stream will have this flag set to
          * true; only those which were thrown <i>during serialization</i> will
          * </p>
+         *
          * @return true iff the object was an exception thrown during serialization
          */
         public boolean isExceptionObject();
         /**
          * Sets the flag that tells whether or not this object is an exception that was caught
          * during serialization.
+         *
          * @param value the new value to use
          */
         public void setIsExceptionObject(boolean value);
+    }

     package jdeserialize;
     import java.io.*;
     import java.util.*;
     /**
      * Provides a skeleton content implementation.
      */
     public class contentbase implements content {
         public int handle;
         public boolean isExceptionObject;
         protected contenttype type;
         public contentbase(contenttype type) {
             this.type = type;
+        }
         public boolean isExceptionObject() {
             return isExceptionObject;
+        }
         public void setIsExceptionObject(boolean value) {
             isExceptionObject = value;
+        }
         public contenttype getType() {
             return type;
+        }
         public int getHandle() {
             return this.handle;
+        }
         public void validate() throws ValidityException {
+        }
+    }

demo_jh/Deserializer_tests/src/jdeserialize/contenttype.java
1		package jdeserialize;
2
3		public enum contenttype {
4		INSTANCE, CLASS, ARRAY, STRING, ENUM, CLASSDESC, BLOCKDATA, EXCEPTIONSTATE
5		}

     package jdeserialize;
     import java.io.*;
     import java.util.*;
     /**
      * <p>
      * Represents an enum instance.  As noted in the serialization spec, this consists of
      * merely the class description (represented by a classdesc) and the string corresponding
      * to the enum's value.  No other fields are ever serialized.
      * </p>
      */
     public class enumobj extends contentbase {
         /**
          * The enum's class description.
          */
         public classdesc classdesc;
         /**
          * The string that represents the enum's value.
          */
         public stringobj value;
         /**
          * Constructor.
+         *
          * @param handle the enum's handle
          * @param cd the enum's class description
          * @param so the enum's value
          */
         public enumobj(int handle, classdesc cd, stringobj so) {
             super(contenttype.ENUM);
             this.handle = handle;
             this.classdesc = cd;
             this.value = so;
+        }
         public String toString() {
             return "[enum " + jdeserialize.hex(handle) + ": " + value.value + "]";
+        }
+    }

     package jdeserialize;
     import java.io.*;
     import java.util.*;
     /**
      * <p>
      * This object contains embedded information about a serialization that failed, throwing
      * an exception.  It includes the actual exception object (which was serialized by the
      * ObjectOutputStream) and the raw bytes of the stream data that was read before the
      * exception was recognized.
      * </p>
+     *
      * <p>
      * For the mechanics of exception serialization, see the Object Serialization
      * Specification.
      * </p>
      */
     public class exceptionstate extends contentbase {
         /**
          * The serialized exception object.
          */
         public content exceptionobj;
         /**
          * <p>
          * An array of bytes representing the data read before the exception was encountered.
          * Generally, this starts with the first "tc" byte (cf. protocol spec), which is an
          * ObjectStreamConstants value and ends with 0x78 (the tc byte corresponding to
          * TC_EXCEPTION).  However, this isn't guaranteed; it may include *more* data.
          * </p>
+         *
          * <p>
          * In other words, this is the incomplete object that was being written while the
          * exception was caught by the ObjectOutputStream.  It is not likely to be cleanly
          * parseable.
          * </p>
+         *
          * <p>
          * The uncertainty centers around the fact that this data is gathered by jdeserialize
          * using a LoggerInputStream, and the underlying DataInputStream may have read more
          * than is necessary.  In all tests conducted so far, the above description is
          * accurate.
          * </p>
          */
         public byte[] streamdata;
         /**
          * Consturctor.
          * @param exobj the serialized exception object
          * @param data the array of stream bytes that led up to the exception
          */
         public exceptionstate(content exobj, byte[] data) {
             super(contenttype.EXCEPTIONSTATE);
             this.exceptionobj = exobj;
             this.streamdata = data;
             this.handle = exobj.getHandle();
+        }
         public String toString() {
             StringBuffer sb = new StringBuffer();
             sb.append("[exceptionstate object " + exceptionobj.toString() + "  buflen " + streamdata.length);
             if(streamdata.length > 0) {
                 for(int i = 0; i < streamdata.length; i++) {
                     if((i % 16) == 0) {
                         sb.append(jdeserialize.linesep).append(String.format("%7x: ", Integer.valueOf(i)));
+                    }
                     sb.append(" ").append(jdeserialize.hexnoprefix(streamdata[i]));
+                }
                 sb.append(jdeserialize.linesep);
+            }
             sb.append("]");
             return sb.toString();
+        }
+    }

     package jdeserialize;
     import java.io.*;
     import java.util.*;
     /**
      * This class represents a field within a class description/declaration (classdesc).  It
      * contains information about the type and name of the field.  Fields themselves don't
      * have a handle; inside the stream, they exist only as part of a class description.
      */
     public class field {
         /**
          * The type of the field.
          */
         public fieldtype type;
         /**
          * The name of the field.
          */
         public String name;
         /**
          * The string object representing the class name.
          */
         public stringobj classname;
         private boolean isInnerClassReference = false;
         /**
          * Tells whether or not this class is an inner class reference.  This value is set by
          * connectMemberClasses() -- if this hasn't been called, or if the field hasn't been
          * otherwise set by setIsInnerClassReference(), it will be false;
+         *
          * @return true if the class is an inner class reference
          */
         public boolean isInnerClassReference() {
             return isInnerClassReference;
+        }
         /**
          * Sets the flag that denotes whether this class is an inner class reference.
+         *
          * @param nis the value to set; true iff the class is an inner class reference.
          */
         public void setIsInnerClassReference(boolean nis) {
             this.isInnerClassReference = nis;
+        }
         /**
          * Constructor.
+         *
          * @param type the field type
          * @param name the field name
          * @param classname the class name
          */
         public field(fieldtype type, String name, stringobj classname) throws ValidityException {
             this.type = type;
             this.name = name;
             this.classname = classname;
             if(classname != null) {
                 validate(classname.value);
+            }
+        }
         /**
          * Constructor for simple fields.
+         *
          * @param type the field type
          * @param name the field name
          */
         public field(fieldtype type, String name) throws ValidityException {
             this(type, name, null);
+        }
         /**
          * Get a string representing the type for this field in Java (the language)
          * format.
          * @return a string representing the fully-qualified type of the field
          * @throws IOException if a validity or I/O error occurs
          */
         public String getJavaType() throws IOException {
             return jdeserialize.resolveJavaType(this.type, this.classname == null ? null : this.classname.value, true, false);
+        }
         /**
          * Changes the name of an object reference to the name specified.  This is used by
          * the inner-class-connection code to fix up field references.
          * @param newname the fully-qualified class
          * @throws ValidityException if the field isn't a reference type, or another
          * validity error occurs
          */
         public void setReferenceTypeName(String newname) throws ValidityException {
             if(this.type != fieldtype.OBJECT) {
                 throw new ValidityException("can't fix up a non-reference field!");
+            }
             String nname = "L" + newname.replace('.', '/') + ";";
             this.classname.value = nname;
+        }
         public void validate(String jt) throws ValidityException {
             if(this.type == fieldtype.OBJECT) {
                 if(jt == null) {
                     throw new ValidityException("classname can't be null");
+                }
                 if(jt.charAt(0) != 'L') {
                     throw new ValidityException("invalid object field type descriptor: " + classname.value);
+                }
                 int end = jt.indexOf(';');
                 if(end == -1 || end != (jt.length()-1)) {
                     throw new ValidityException("invalid object field type descriptor (must end with semicolon): " + classname.value);
+                }
+            }
+        }
+    }

     package jdeserialize;
     import java.io.*;
     import java.util.*;
     /**
      * <p>
      * Enum class that describes the type of a field encoded inside a classdesc description.
      * </p>
+     *
      * <p>
      * This stores both information on the type (reference/array vs. primitive) and, in cases
      * of reference or array types, the name of the class being referred to.
      * </p>
      */
     public enum fieldtype {
         BYTE ('B', "byte"),
         CHAR ('C', "char"),
         DOUBLE ('D', "double"),
         FLOAT ('F', "float"),
         INTEGER ('I', "int"),
         LONG ('J', "long"),
         SHORT ('S', "String"),
         BOOLEAN ('Z', "boolean"),
         ARRAY ('['),
         OBJECT ('L');
         private final char ch;
         private final String javatype;
         /**
          * Constructor for non-object (primitive) types.
+         *
          * @param ch the character representing the type (must match one of those listed in
          * prim_typecode or obj_typecode in the Object Serialization Stream Protocol)
          */
         fieldtype(char ch) {
             this(ch, null);
+        }
         /**
          * Constructor.
+         *
          * @param ch the character representing the type (must match one of those listed in
          * prim_typecode or obj_typecode in the Object Serialization Stream Protocol)
          * @param javatype the name of the object class, where applicable (or null if not)
          */
         fieldtype(char ch, String javatype) {
             this.ch = ch;
             this.javatype = javatype;
+        }
         /**
          * Gets the class name for a reference or array type.
+         *
          * @return the name of the class being referred to, or null if this is not a
          * reference/array type
          */
         public String getJavaType() {
             return this.javatype;
+        }
         /**
          * Gets the type character for this field.
+         *
          * @return the type code character for this field; values will be one of those in
          * prim_typecode or obj_typecode in the protocol spec
          */
         public char ch() { return ch; }
         /**
          * Given a byte containing a type code, return the corresponding enum.
+         *
          * @param b the type code; must be one of the charcaters in obj_typecode or
          * prim_typecode in the protocol spec
          * @return the corresponding fieldtype enum
          * @throws ValidityException if the type code is invalid
          */
         public static fieldtype get(byte b) throws ValidityException {
             switch(b) {
                 case 'B':
                     return BYTE;
                 case 'C':
                     return CHAR;
                 case 'D':
                     return DOUBLE;
                 case 'F':
                     return FLOAT;
                 case 'I':
                     return INTEGER;
                 case 'J':
                     return LONG;
                 case 'S':
                     return SHORT;
                 case 'Z':
                     return BOOLEAN;
                 case '[':
                     return ARRAY;
                 case 'L':
                     return OBJECT;
                 default:
                     throw new ValidityException("invalid field type char: " + b);
+            }
+        }
+    }

     package jdeserialize;
     import java.io.*;
     import java.util.*;
     /**
      * Represents an instance of a non-enum, non-Class, non-ObjectStreamClass,
      * non-array class, including the non-transient field values, for all classes in its
      * hierarchy and inner classes.
      */
     public class instance extends contentbase {
         /**
          * Collection of field data, organized by class description.
          */
         public Map<classdesc, Map<field, Object>> fielddata;
         /**
          * Class description for this instance.
          */
         public classdesc classdesc;
         /**
          * Constructor.
          */
         public instance() {
             super(contenttype.INSTANCE);
             this.fielddata = new HashMap<classdesc, Map<field, Object>>();
+        }
         public String toString() {
             StringBuffer sb = new StringBuffer();
             sb.append(classdesc.name).append(' ').append("_h").append(jdeserialize.hex(handle))
                 .append(" = r_").append(jdeserialize.hex(classdesc.handle)).append(";  ");
             //sb.append("// [instance " + jdeserialize.hex(handle) + ": " + jdeserialize.hex(classdesc.handle) + "/" + classdesc.name).append("]");
             return sb.toString();
+        }
         /**
          * Object annotation data.
          */
         public Map<classdesc, List<content>> annotations;
+    }

     package jdeserialize;
     import java.io.*;
     import java.util.*;
     import java.util.regex.*;
     /**
      * The main user-facing class for the jdeserialize library.  Also the implementation of
      * the command-line tool.<br/>
      * <br/>
      * Library:<br/>
      * <br/>
      * The jdeserialize class parses the stream (method run()).  From there, call the
      * getContent() method to get an itemized list of all items written to the stream,
      * or getHandleMaps() to get a list of all handle->content maps generated during parsing.
      * The objects are generally instances that implement the interface "content"; see the
      * documentation of various implementors to get more information about the inner
      * representations.<br/>
      * <br/>
      * To enable debugging on stdout, use the enableDebug() or disableDebug() options.   <br/>
      * <br/>
      * <br/>
      * Command-line tool:   <br/>
      * <br/>
      * The tool reads in a set of files and generates configurable output on stdout.  The
      * primary output consists of three separate stages.  The first stage is  a textual
      * description of every piece of content in the stream, in the order it was written.
      * There is generally a one-to-one mapping between ObjectOutputStream.writeXXX() calls and
      * items printed in the first stage.  The first stage may be suppressed with the
      * -nocontent command-line option. <br/>
      * <br/>
      * The second stage is a list of every class declaration serialized in the file.  These

Projekt

Obecné

Profil

ASWI - Pokročilé softwarové inženýrství » ASWI 2020 » Java object universal deserializer (GK Software) - Horký

Revize 53fe2660

Přidáno uživatelem Jan Havlíček před asi 5 roky(ů)

Projekt

Obecné

Profil

ASWI - Pokročilé softwarové inženýrství » ASWI 2020 » Java object universal deserializer (GK Software) - Horký

Revize 53fe2660

Přidáno uživatelem Jan Havlíček před asi 5 roky(ů)

Související úkoly