Revize 03a2d08f

#7794

Vytvoření hlavního projektu.

demo_mh/Deserializer/src/deserialize/Deserializer.java

@@ -35 +35 @@
 	@Override
 	public void init() throws Exception {
 		super.init();
-		testing = false;
+		testing = true;
 	}
 	
 	@Override

demo_mh/Deserializer/src/deserialize/Formatter.java

@@ -1 @@
-package deserialize;
-
-public class Formatter {
-
-	public static int createInt(byte first, byte second) {
-		return ((first & 0xFF) << 8) | (second & 0xFF);
-	}
-	
-}

project/.gitignore

@@ +1 @@
+/.metadata/

project/Deserializer/.classpath

@@ +1 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="lib" path="D:/Michal/University/1/LS/ASWI/semestralky/Deserializer/aswi2020horky/project/Deserializer/libs/jackson-core-asl-1.9.13.jar"/>
+	<classpathentry kind="lib" path="D:/Michal/University/1/LS/ASWI/semestralky/Deserializer/aswi2020horky/project/Deserializer/libs/jackson-mapper-asl-1.9.13.jar"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>

project/Deserializer/.gitignore

@@ +1 @@
+/bin/

project/Deserializer/.project

@@ +1 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>Deserializer</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

project/Deserializer/libs/Licenses

@@ +1 @@
+
+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:
+
+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. 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.

project/Deserializer/results.json

@@ +1 @@
+{
+  "handle" : 8257537,
+  "isExceptionObject" : false,
+  "type" : "INSTANCE",
+  "fielddata" : {
+    "[cd 0x7e0000: name java.util.Hashtable uid 1421746759512286392]" : {
+      "jdeserialize.field@204b315d" : 0.75,
+      "jdeserialize.field@2e8ccb24" : 8
+    }
+  },
+  "classdesc" : {
+    "handle" : 8257536,
+    "isExceptionObject" : false,
+    "type" : "CLASSDESC",
+    "classtype" : "NORMALCLASS",
+    "name" : "java.util.Hashtable",
+    "serialVersionUID" : 1421746759512286392,
+    "descflags" : 3,
+    "fields" : [ {
+      "type" : "FLOAT",
+      "name" : "loadFactor",
+      "classname" : null,
+      "javaType" : "float",
+      "innerClassReference" : false
+    }, {
+      "type" : "INTEGER",
+      "name" : "threshold",
+      "classname" : null,
+      "javaType" : "int",
+      "innerClassReference" : false
+    } ],
+    "innerclasses" : [ ],
+    "annotations" : [ ],
+    "superclass" : null,
+    "interfaces" : null,
+    "enumconstants" : [ ],
+    "arrayClass" : false,
+    "innerClass" : false,
+    "staticMemberClass" : false,
+    "localInnerClass" : false,
+    "exceptionObject" : false
+  },
+  "annotations" : {
+    "[cd 0x7e0000: name java.util.Hashtable uid 1421746759512286392]" : [ {
+      "handle" : 0,
+      "isExceptionObject" : false,
+      "type" : "BLOCKDATA",
+      "buf" : "AAAACwAAAAA=",
+      "exceptionObject" : false
+    } ]
+  },
+  "exceptionObject" : false
+}

project/Deserializer/src/Converter.java

@@ +1 @@
+import java.io.File;
+import java.io.IOException;
+import java.util.List;
+
+import org.codehaus.jackson.map.ObjectMapper;
+import org.codehaus.jackson.map.ObjectWriter;
+
+import jdeserialize.content;
+import jdeserialize.jdeserialize;
+
+public class Converter extends Thread {
+	
+	private Deserializer main;
+	
+	private File input;
+	private File output;
+	
+	public Converter(Deserializer main, File inputFilename, File outputFilename) {
+		this.main = main;
+		this.input = inputFilename;
+		this.output = outputFilename;
+	}
+	
+	@Override
+	public void run() {
+		super.run();
+		
+		try {
+			String json = convert(FileWorker.loadByteArray(input));
+			
+			String title = "Ulo?en? JSON";
+			if (FileWorker.saveJson(output, json)) {
+				System.out.println("The JSON file was saved correctly.");
+				Report.info(title, null, "Ulo?en? JSON souboru prob?hlo v po??dku.");
+			} else {
+				System.out.println("There was an error saving the JSON file.");
+				Report.error(title, null, "P?i ukl?d?n? JSON souboru nastala chyba.");
+			}
+		} catch (IOException e) {
+			System.out.println("There was an error loading the file.");
+			e.printStackTrace();
+			Report.error("Na??t?n? souboru", null, "P?i na??t?n? souboru do?lo k chyb?.");
+		}
+
+		main.convertIsComplete();
+	}
+	
+	private String convert(byte[] buffer) {
+		try {
+			System.out.println("Deserialization begins.");
+			jdeserialize deserializer = new jdeserialize(buffer);
+			
+			// gets the "contents" into an array - returnes the deserialization of all
+            // 'writes' into serialized object via objectOutputStream
+            List<content> cntnts = deserializer.getContent();
+
+            // testing with only first of the contents
+            ObjectWriter ow = new ObjectMapper().writer().withDefaultPrettyPrinter();
+            String json = ow.writeValueAsString(cntnts.get(0));
+            
+            System.out.println("Task completed.");
+            return json;
+		} catch (IOException e) {
+			System.out.println("An error occurred while processing!");
+			e.printStackTrace();
+			return null;
+		}
+	}
+
+}

project/Deserializer/src/Deserializer.java

@@ +1 @@
+import java.io.File;
+
+import javafx.application.Application;
+import javafx.geometry.Insets;
+import javafx.geometry.Pos;
+import javafx.scene.Parent;
+import javafx.scene.Scene;
+import javafx.scene.control.Button;
+import javafx.scene.control.Label;
+import javafx.scene.layout.HBox;
+import javafx.scene.layout.VBox;
+import javafx.stage.FileChooser;
+import javafx.stage.Stage;
+
+public class Deserializer extends Application {
+	
+	private Stage stage;
+	private File inputFile;
+	private File outputFile;
+	
+	Button convert;
+	
+	// TODO delete after deserializer debugging is complete...
+	private boolean testing;
+	
+	public static void main(String[] args) {
+		launch(args);
+	}
+
+	@Override
+	public void init() throws Exception {
+		super.init();
+		testing = true;
+	}
+	
+	@Override
+	public void start(Stage stage) throws Exception {
+		this.stage = stage;
+		stage.setTitle("Java object universal deserializer");
+		stage.setScene(createScene());
+		stage.setMinWidth(400);
+		stage.show();
+	}
+	
+	private Scene createScene() {
+		return new Scene(createLayout());
+	}
+	
+	private Parent createLayout() {
+		VBox layout = new VBox();
+		layout.setPadding(new Insets(10.0));
+		layout.setSpacing(10.0);
+		
+		Label forInputFile = new Label("Soubor k deserializaci:");
+		Label inputFile = new Label("    Je?t? nebyl vybr?n ??dn? soubor...");
+		inputFile.setStyle("-fx-font-style: italic;");
+		VBox forInput = new VBox();
+		forInput.getChildren().add(forInputFile);
+		forInput.getChildren().add(inputFile);
+		
+		Label forOutputFile = new Label("V?stupn? soubor:");
+		Label outputFile = new Label("    Je?t? nebyl vybr?n ??dn? soubor...");
+		outputFile.setStyle("-fx-font-style: italic;");
+		VBox forOutput = new VBox();
+		forOutput.getChildren().add(forOutputFile);
+		forOutput.getChildren().add(outputFile);
+		
+		convert = new Button("P?ev?st");
+		convert.setOnAction(event -> {
+			// a.data a b.data are customers test files (binary files).
+			convert.setDisable(true);
+			Converter thread = new Converter(this, testing ? new File("a.data") : this.inputFile, testing ? new File("results.json") : this.outputFile);
+			thread.start();
+		});
+		convert.setDisable(!testing);
+		Button setInputFile = new Button("Vstupn? soubor");
+		setInputFile.setOnAction(event -> {
+			FileChooser fCh = new FileChooser();
+			fCh.setInitialDirectory(new File("."));
+			// The input can be a zip file or file without a specific extension -> file chooser without extension filters...
+			// fCh.getExtensionFilters().add(new FileChooser.ExtensionFilter("Binary Files", "*.out"));
+			File file = fCh.showOpenDialog(stage);
+			if (file != null) {
+				this.inputFile = file;
+				inputFile.setText(this.inputFile == null ? "" : this.inputFile.getAbsolutePath());
+				inputFile.setStyle("-fx-font-weight: bold;");
+				convert.setDisable(this.inputFile == null || this.outputFile == null);
+			}
+		});
+		Button setOutputFile = new Button("V?stupn? soubor");
+		setOutputFile.setOnAction(event -> {
+			FileChooser fCh = new FileChooser();
+			fCh.setInitialDirectory(new File("."));
+			fCh.getExtensionFilters().add(new FileChooser.ExtensionFilter("JSON Files", "*.json"));
+			File file = fCh.showSaveDialog(stage);
+			if (file != null) {
+				this.outputFile = file;
+				outputFile.setText(this.outputFile == null ? "" : this.outputFile.getAbsolutePath());
+				outputFile.setStyle("-fx-font-weight: bold;");
+				convert.setDisable(this.inputFile == null || this.outputFile == null);
+			}
+		});
+		HBox footer = new HBox();
+		footer.setSpacing(10.0);
+		footer.setAlignment(Pos.CENTER_RIGHT);
+		footer.getChildren().add(setInputFile);
+		footer.getChildren().add(setOutputFile);
+		footer.getChildren().add(convert);
+		
+		layout.getChildren().add(forInput);
+		layout.getChildren().add(forOutput);
+		layout.getChildren().add(footer);
+		
+		return layout;
+	}
+	
+	public void convertIsComplete() {
+		convert.setDisable(false);
+	}
+	
+}

project/Deserializer/src/FileWorker.java

@@ +1 @@
+import java.io.BufferedInputStream;
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.NoSuchElementException;
+import java.util.zip.ZipException;
+import java.util.zip.ZipInputStream;
+
+public class FileWorker {
+	
+	public static byte[] loadByteArray(File file) throws IOException {
+		byte buffer[];
+		
+		/*
+		 * Note.
+		 * For ZIP - the first four bytes should be one of the following combinations:
+		 *     50 4B 03 04
+		 *     50 4B 05 06 (empty archive)
+		 *     50 4B 07 08 (spanned archive)
+		 * Source: https://en.wikipedia.org/wiki/List_of_file_signatures
+		 */
+	    try {
+	    	
+	    	ZipInputStream zipIS = new ZipInputStream(new FileInputStream(file));
+	    	
+	        if (zipIS.getNextEntry() == null) {
+	        	zipIS.close();
+	        	throw new NoSuchElementException();
+	        }
+	        
+	        System.out.println("The file is a zip archive...");
+	        List<Byte> _buffer = new ArrayList<Byte>();
+	        while (true) {
+	        	int value = zipIS.read();
+	        	if (value < 0) {
+	        		break;
+	        	} else {
+	        		_buffer.add((byte) value);
+	        	}
+	        }
+	        
+	        buffer = new byte[_buffer.size()];
+	        for (int i = 0; i < buffer.length; i++) {
+	        	buffer[i] = _buffer.get(i);
+	        }
+	        
+	        zipIS.close();
+	        
+		} catch (NoSuchElementException | ZipException e) {
+			
+			System.out.println("The file is not a zip archive...");
+			buffer = new byte[(int) file.length()];
+	    	BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file));
+	    	bis.read(buffer);
+			bis.close();
+			
+		}
+	    
+	    System.out.println("Bytes from the file were loaded correctly.");
+	    return buffer;
+	}
+
+	public static boolean saveJson(File file, String json) {
+        boolean retValue = false;
+		try {
+            FileWriter fw = new FileWriter(file);
+            BufferedWriter bw = new BufferedWriter(fw);
+            bw.write(json);
+            bw.flush();
+            bw.close();
+            retValue = true;
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+		return retValue;
+	}
+	
+}

project/Deserializer/src/Report.java

@@ +1 @@
+import com.sun.javafx.stage.StageHelper;
+
+import javafx.application.Platform;
+import javafx.geometry.Rectangle2D;
+import javafx.scene.control.Alert;
+import javafx.scene.control.Alert.AlertType;
+import javafx.stage.Screen;
+
+public class Report {
+	
+	private static final int HEIGHT = 200;
+	private static final int WIDTH = 500;
+	
+	private static void setPosition(Alert alert) {
+		if (StageHelper.getStages() != null && StageHelper.getStages().size() != 0) {
+			if (Screen.getPrimary() != null && Screen.getPrimary().getVisualBounds() != null) {
+				Rectangle2D primScreenBounds = Screen.getPrimary().getVisualBounds();
+				alert.setX((primScreenBounds.getWidth() - WIDTH - 20) / 2);
+		        alert.setY((primScreenBounds.getHeight() - HEIGHT - 20) / 3);
+			}
+			alert.initOwner(StageHelper.getStages().get(StageHelper.getStages().size() - 1));
+		}
+	}
+	
+	private static Alert createAlert(AlertType type, String title, String header, String content) {
+		Alert alert = new Alert(type);
+		alert.setResizable(true);
+		alert.getDialogPane().setPrefWidth(WIDTH);
+		alert.setTitle(title);
+		alert.setHeaderText(header);
+		alert.setContentText(content);
+		setPosition(alert);
+		return alert;
+	}
+	
+	public static void error(String title, String header, String content) {
+		Platform.runLater(()->{
+			createAlert(AlertType.WARNING, title, header, content).showAndWait();
+        });
+	}
+	
+	public static void info(String title, String header, String content) {
+		Platform.runLater(()->{
+			createAlert(AlertType.INFORMATION, title, header, content).showAndWait();
+        });
+	}
+	
+	public static boolean confirm(String title, String header, String content) {
+		Alert alert = createAlert(AlertType.CONFIRMATION, title, header, content);
+		alert.showAndWait();
+		if (alert.getResult().getText().equals("OK")) {
+			return true;
+		} else {
+			return false;
+		}
+	}
+	
+}

project/Deserializer/src/jdeserialize/ExceptionReadException.java

@@ +1 @@
+package jdeserialize;
+import java.io.*;
+
+/**
+ * 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;
+    }
+}
+

project/Deserializer/src/jdeserialize/Getopt.java

@@ +1 @@
+package jdeserialize;
+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 {
+            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();
+        }
+    }
+}

project/Deserializer/src/jdeserialize/LoggerInputStream.java

@@ +1 @@
+package jdeserialize;
+
+import java.io.*;
+
+/**
+ * <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 ByteArrayInputStream innerStream = null;
+    private ByteArrayOutputStream baos = null;
+    private boolean recording = false; 
+
+    public LoggerInputStream(byte[] buffer) {
+        super();
+        this.innerStream = new ByteArrayInputStream(buffer);
+    }
+    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();
+    }
+}

project/Deserializer/src/jdeserialize/ValidityException.java

@@ +1 @@
+package jdeserialize;
+import java.io.*;
+
+/**
+ * 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);
+    }
+}
+

project/Deserializer/src/jdeserialize/arraycoll.java

@@ +1 @@
+package jdeserialize;
+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();
+    }
+}

project/Deserializer/src/jdeserialize/arrayobj.java

@@ +1 @@
+package jdeserialize;
+
+/**
+ * <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() + "]";
+    }
+}
+

project/Deserializer/src/jdeserialize/blockdata.java

@@ +1 @@
+package jdeserialize;
+
+/**
+ * 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]";
+    }
+}

project/Deserializer/src/jdeserialize/classdesc.java

@@ +1 @@
+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!");
+            }
+        }
+    }
+}
+

project/Deserializer/src/jdeserialize/classdesctype.java

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

project/Deserializer/src/jdeserialize/classobj.java

@@ +1 @@
+package jdeserialize;
+
+/**
+ * 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() + "]";
+    }
+}
+

project/Deserializer/src/jdeserialize/content.java

@@ +1 @@
+package jdeserialize;
+
+/**
+ * <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);
+}
+

project/Deserializer/src/jdeserialize/contentbase.java

@@ +1 @@
+package jdeserialize;
+
+/**
+ * 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 {
+    }
+}
+

project/Deserializer/src/jdeserialize/contenttype.java

@@ +1 @@
+package jdeserialize;
+
+public enum contenttype {
+    INSTANCE, CLASS, ARRAY, STRING, ENUM, CLASSDESC, BLOCKDATA, EXCEPTIONSTATE
+}

project/Deserializer/src/jdeserialize/enumobj.java

@@ +1 @@
+package jdeserialize;
+
+/**
+ * <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 + "]";
+    }
+}