aswi2020horky-gitlab/demo_jh/Deserializer_tests/src/app/App.java @ a2822466

package app;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import jdeserialize.Getopt;
import jdeserialize.classdesc;
import jdeserialize.content;
import jdeserialize.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
     **/
    public static void main(String[] args) throws Exception {
        App app = new App();

        // app.standartSerializationDeserialization();

        // https://code.google.com/archive/p/jdeserialize/wikis/Documentation.wiki
        //test with calling the name of original jd project
        //app.jdCallMain();

        // test directly through code call
        app.jdCallLib("serialized/simple.out");
    }

    private void jdCallLib(String filename)
    {
        try
        {
            //FileInputStream as usual
            FileInputStream fis = null;
            fis = new FileInputStream(filename);
            
            //creating an instance of jdeserialize with given filename
            jdeserialize jd = new jdeserialize(filename);
            //running the main process of deserialization
            jd.run(fis, false);
            
            //gets the "contents" into an array - returnes the deserialization of all
            // 'writes' into serialized object via objectOutputStream
            ArrayList<content> cntnts = (ArrayList<content>) jd.getContent();

            //gets first object of content type
            // - tested only with just one object.
            // the content here is just an interface.
            // The classes that implements the interface content (all of them through class contentbase)
            // are: arrayobj, blockdata, classdesc, classobj, enumobj, exceptionstate, instance, stringobj
            content locContent = cntnts.get(0);

            classdesc objectDescription = locContent.


            int c = 0;
        }
        catch (IOException e) 
        {

        }
    }

    private void jdCallMain(String filename)
    {
        String[] myArgs= new String[1];
        myArgs[0] = filename;
        jdeserialize.main(myArgs); //testing call without any options. Outputs the deserialized data into console.
    }

    private void standartSerializationDeserialization() {
        try {
            System.out.println("Starting...");

            this.serialize(new samples.ok.Simple(), "serialized/simple.out");

            samples.nok.Simple test1 = this.deserialize("serialized/simple.out");

        } catch (Exception e) {
            System.out.println(e.toString());
            System.out.println(e.getMessage());
        }
    }

    /**
     * Standard way of deserializing objects with java.
     * 
     * Taken from example method, doc
     **/
    private <T> T deserialize(String inputFilePath) {
        try {
            FileInputStream fis = new FileInputStream(inputFilePath);
            ObjectInputStream ois = new ObjectInputStream(fis);
            T deserialized = (T) ois.readObject();
            System.out.println(deserialized.toString());
            ois.close();

            return deserialized;
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * Standard way of serializing objects with java.
     * 
     * Taken from example method, doc
     **/
    private void serialize(Object obj, String outputPath) {
        try {
            File toWrite = new File(outputPath);
            toWrite.createNewFile();

            FileOutputStream fos = new FileOutputStream(toWrite, false);
            ObjectOutputStream oos = new ObjectOutputStream(fos);

            oos.writeObject(obj);
            oos.flush();
            oos.close();
            System.out.println("serialized.");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}