# Interface Externalizable

All Known Implementing Classes:
  `AccessToken, CachedData, Cookie, Receipt`

public interface Externalizable

`Externalizable` is similar to the Java SE `Externalizable` interface this interface. Notice that due to the lack of reflection and use of obfuscation these objects must be registered with the Util class.

Also notice that all externalizable objects must have a default public constructor.

Built-In Object types

The externalization process supports serializing these types and considers them to be `Externalizable`. E.g. you can just write `Storage.getInstance().writeObject(new Object[] {"Str1", "Str2"`);} and it will work as expected.

Notice that while these objects can be written, the process doesn't guarantee they will be read with the same object type. E.g. if you write a `java.util.LinkedList` you could get back a `java.util.ArrayList` as both implement `java.util.Collection`:

`java.lang.String`, `java.util.Collection`, `java.util.Map`, `java.util.ArrayList`, `java.util.HashMap`, `java.util.Vector`, `java.util.Hashtable`, `java.lang.Integer`, `java.lang.Double`, `java.lang.Float`, `java.lang.Byte`, `java.lang.Short`, `java.lang.Long`, `java.lang.Character`, `java.lang.Boolean`, `Object[]`, `byte[]`, `int[]`, `float[]`, `long[]`, `double[]`.

The sample below demonstrates the usage and registration of the `Externalizable` interface:

    // File: Main.java
    public Main {
      public void init(Object o) {
        theme = UIManager.initFirstTheme("/theme");

        // IMPORTANT: Notice we don't use MyClass.class.getName()! This won't work due to obfuscation!
        Util.register("MyClass", MyClass.class);
      }

      public void start() {
        //...
      }

      public void stop() {
        //...
      }

      public void destroy() {
        //...
      }
    }

    // File: MyClass.java
    public MyClass implements Externalizable {
      // allows us to manipulate the version, in this case we are demonstrating a data change between the initial release
      // and the current state of object data
      private static final int VERSION = 2;

      private String name;
      private Map data;

      // this field was added after version 1
      private Date startedAt;

      public int getVersion() {
        return VERSION;
      }

      public void externalize(DataOutputStream out) throws IOException {
        Util.writeUTF(name, out);
        Util.writeObject(data, out);
        if(startedAt != null) {
            out.writeBoolean(true);
            out.writeLong(startedAt.getTime());
        } else {
            out.writeBoolean(false);
        }
      }
      public void internalize(int version, DataInputStream in) throws IOException {
        name = Util.readUTF(in);
        data = (Map)Util.readObject(in);
        if(version > 1) {
            boolean hasDate = in.readBoolean();
            if(hasDate) {
                startedAt = new Date(in.readLong());
            }
        }
      }
      public String getObjectId() {
        // IMPORTANT: Notice we don't use getClass().getName()! This won't work due to obfuscation!
        return "MyClass";
      }
    }

    // File: ReadAndWrite.java
    // will read the file or return null if failed
    MyClass object = (MyClass)Storage.getInstance().readObject("NameOfFile");

    // write the object back to storage
    Storage.getInstance().writeObject("NameOfFile", object);

WARNING: The externalization process caches objects so the app will seem to work and only fail on restart!

- ## Method Summary

  Modifier and Type
  Method
  Description
  `void`
  `externalize(DataOutputStream out)`
  Allows us to store an object state, this method must be implemented in order to save the state of an object
  `String`
  `getObjectId()`
  The object id must be unique, it is used to identify the object when loaded even when it is obfuscated.
  `int`
  `getVersion()`
  Returns the version for the current persistance code, the version will be pased to internalized thus allowing the internalize method to recognize classes persisted in older revisions
  `void`
  `internalize(int version, DataInputStream in)`
  Loads the object from the input stream and allows deserialization

- ## Method Details

  - ### getVersion

    int getVersion()

    Returns the version for the current persistance code, the version will be pased to internalized thus allowing the internalize method to recognize classes persisted in older revisions

    ###### Returns

    version number for the persistant code

  - ### externalize

    void externalize(DataOutputStream out) throws IOException

    Allows us to store an object state, this method must be implemented in order to save the state of an object

    ###### Parameters

    - `out`: the stream into which the object must be serialized

    ###### Throws

    - `java.io.IOException`: the method may throw an exception
    Throws:
      `IOException`

  - ### internalize

    void internalize(int version, DataInputStream in) throws IOException

    Loads the object from the input stream and allows deserialization

    ###### Parameters

    - `version`: the version the class returned during the externalization processs

    - `in`: the input stream used to load the class

    ###### Throws

    - `java.io.IOException`: the method may throw an exception
    Throws:
      `IOException`

  - ### getObjectId

    String getObjectId()

    The object id must be unique, it is used to identify the object when loaded even when it is obfuscated.

    ###### Returns

    a unique id