Serializer

package com.alandude.serialization;

import java.util.ArrayList;
import java.util.List;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.nio.file.Path;
import java.nio.file.Paths;

public final class Serializer {
    private Serializer() { }

    /** Serializes an object into a given output file.
     * Object data always start with a @, and ending with a % */
    private static void serialize(Object o, OutputStream out, List<Object> alreadySerialized) throws IOException {

        try {

            /* Store the name of the object's class
             *
             * Format:
             *   @[CLASS_NAME]^
             */
            out.write('@');
            for (char c : o.getClass().getName().toCharArray())
                out.write(c);
            out.write('^');

            /* Store the name & value of every field in the object
             * The format:
             *
             *    [NAME]:[TYPE_TAG][VALUE]
             *    [NAME]:[TYPE_TAG][VALUE]
             *     ...
             */
            for (Field field : o.getClass().getDeclaredFields()) {
                field.setAccessible(true);

                // If this field is transient, don't even write this to the file
                // So when we deserialize it, we'll leave the field be, Java will
                // set it to a default value.
                if (Modifier.isTransient(field.getModifiers()))
                    continue;

                /* Write the field name */
                for (char c : field.getName().toCharArray())
                    out.write(c);
                out.write(':');


                /* Store the field's value */
                final Class<?> type = field.getType();
                final Object val = field.get(o);

                /* This field is not transient, therefore we can save its state */
                if (type.isPrimitive()) {

                    // Every primitive has a beginning tag:
                    // boolean  0
                    // byte     1
                    // char     2
                    // double   3
                    // float    4
                    // int      5
                    // long     6
                    // short    7

                    // *For objects, they are tagged with 8

                    if (type == Boolean.TYPE) {
                        out.write(0);
                        // 1 = true, 0 = false
                        if ((boolean)val == true)
                            out.write(1);
                        else
                            out.write(0);
                    } else if (type == Byte.TYPE) {
                        out.write(1);
                        out.write((byte) val);
                    } else if (type == Character.TYPE) {
                        out.write(2);
                        out.write((char) val);
                    } else if (type == Double.TYPE) {
                        out.write(3);
                        // TODO: Double
                    } else if (type == Float.TYPE) {
                        out.write(4);
                        // TODO: Float
                    } else if (type == Integer.TYPE) {
                        out.write(5);

                        int i = (int) val;
                        // Apply a mask to contain certain values, shift them so we can
                        // fit them in a byte
                        out.write((i & 0B0000_0000_0000_0000_0000_0000_1111_1111));
                        out.write((i & 0B0000_0000_0000_0000_1111_1111_0000_0000) >> 8);
                        out.write((i & 0B0000_0000_1111_1111_0000_0000_0000_0000) >> 16);
                        out.write((i & 0B1111_1111_0000_0000_0000_0000_0000_0000) >> 24);
                    } else if (type == Long.TYPE) {
                        out.write(6);
                        // TODO: Long
                    } else {
                        /* Shorts */
                        out.write(7);
                        short s = (short) val;
                        // Use bitmasking to get two halves and store them into separate bytes
                        out.write((s & 0B0000_0000_1111_1111));
                        out.write((s & 0B1111_1111_0000_0000) >> 8);
                    }
                } else {
                    /* Objects */
                    if (val != null) {
                        out.write(8);

                        // TODO: Use alreadySerialized, goddamnit

                        // Whenever an object contains references to other objects, we must serialize them as well.
                        // The exact same process takes place for that inner object, except it is written within
                        // the outer class.

                        // This is also the reason why the data format of classes start with @ and end with %.
                        // We can analyze the structure of the data, and figure out what bytes are part of which class.
                        alreadySerialized.add(val);
                        serialize(val, out, alreadySerialized);
                    }
                }
            }

            out.write('%'); // signify that the the data format is finished

        } catch (IllegalArgumentException|IllegalAccessException e) {
            System.out.println("\nAn exception occured when serializing object: " + o);
            System.out.println("---------------------------------------------------------");
            e.printStackTrace();
            System.exit(1);
        }
    }

    public static void serialize(Object o, File file) throws IOException {
        try (OutputStream out = new BufferedOutputStream(new FileOutputStream(file))) {
            serialize(o, out, new ArrayList<Object>());
        }
    }
    public static void serialize(Object o, Path path) throws IOException {
        serialize(o, new File(path.toString()));
    }
    public static void serialize(Object o, String path) throws IOException {
        serialize(o, Paths.get(path));
    }
}