/*
 * @(#)CustomDataExample.java	1.2 97/12/11        
 *
 * Copyright (c) 1997 Sun Microsystems, Inc. All Rights Reserved.
 *
 * This software is the confidential and proprietary information of Sun
 * Microsystems, Inc. ("Confidential Information").  You shall not
 * disclose such Confidential Information and shall use it only in
 * accordance with the terms of the license agreement you entered into
 * with Sun.
 *
 * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
 * SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
 * PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
 * SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
 * THIS SOFTWARE OR ITS DERIVATIVES.
 *
 * 
 */

import java.io.*;
 
/**
 * This example shows how to use writeObject and readObject to encode
 * custom data format. When the persistent data is unwieldy, it is suitable
 * to store it in a more convenient, condensed format. 
 * 
 * Specifically, this example considers the case of a triangular array. A
 * triangular array is simply a 2-dimensional array that is symmetric. So when
 * serializing it, it is desirable to save only 1/2 of the 2-dimensional array
 * rather than the whole.
 *
 * This is different from the Serialization and Serializable Fields API 
 * Example in that this example does not support versioning.  This example
 * differs from using an Externalizable interface in that this example does
 * not have to worry about superclasses.
 *
 * Complied and tested on JDK 1.1 & JDK 1.2.
 *
 * How to run this example:
 *                         Compile this file: javac CustomDataExample.java
 *                         Then run:          java CustomDataExample
 *
 *  This will print out two arrays: one from before serialization and the
 *  other from after deserialization.
 */
public class CustomDataExample implements Serializable {

    int dimension;
 
    int thearray[][];

    /**
     * Create the triangular array of dimension dim and initialize it
     */
    CustomDataExample (int dim) {
  	dimension = dim;
        thearray = new int[dim][dim];
	arrayInit();
    }

    /**
     * Create an CustomDataExample object, serialize it, deserialize it and 
     * see that they are the same. So, basically test that this custom
     * data example's serialization works.
     */
    public static void main(String args[]) {
	CustomDataExample corg = new CustomDataExample(4);
	CustomDataExample cnew = null;
	
	// Serialize the original class object
	try {
	    FileOutputStream fo = new FileOutputStream("cde.tmp");
	    ObjectOutputStream so = new ObjectOutputStream(fo);
	    so.writeObject(corg);
	    so.flush();
	    so.close();
	} catch (Exception e) {
	    System.out.println(e);
	    System.exit(1);
	}
	
	// Deserialize in to new class object
	try {
	    FileInputStream fi = new FileInputStream("cde.tmp");
	    ObjectInputStream si = new ObjectInputStream(fi);  
	    cnew = (CustomDataExample) si.readObject();
            si.close();
	} catch (Exception e) {
	    System.out.println(e);
	    System.exit(1);
	}
    
	// Print out to check the correctness
	System.out.println();
	System.out.println("Printing the original array...");
	System.out.println(corg);
	System.out.println();
	System.out.println("Printing the new array...");
	System.out.println(cnew);
	System.out.println();
	System.out.println("The original and new arrays should be the same!");
	System.out.println();
   }
    
    /** 
     * Write out the dimension and 1/2 of the 2-dimensional array to the
     *  ObjectOutputStream s. readObject depends on this data format.
     */
    private void writeObject(ObjectOutputStream s)
	throws IOException {

	    // save the dimension
	    s.writeInt(dimension);

	    // write out only 1/2 of the 2-dimensional array
	    for (int i = 0; i < dimension; i++) {
		for (int j = 0; j <= i; j++) {
		    s.writeInt(thearray[i][j]);
		}
	    }	    
    }
  
    /** 
     * Read in the dimension and 1/2 of the 2-dimensional array from the
     * ObjectInputStream s. Was written to by writeObject. Also, copy the
     * 1/2 array to the other half to completely fill the symmetric array.
     */
    private void readObject(ObjectInputStream s) 
	throws IOException  {
	    
	    // restore the dimension
	    dimension = s.readInt();
	    
	    // allocate space for the array
	    thearray = new int[dimension][dimension];
	    
	    // first restore 1/2 the 2-dimensional array
	    for (int i = 0; i < dimension; i++) {
		for (int j = 0; j <= i; j++) {
		    thearray[i][j] = s.readInt();
		}
	    }
	    
	    // copy over to the other side
	    for (int i = 0; i < dimension; i++) {
		for (int j = dimension - 1; j > i; j--) {
		    thearray[i][j] = thearray[j][i];
		}
	    }
    }

    /**
     * Initialize the array to some numbers starting from 0 - make it 
     * symmetrical 
     */ 
    void arrayInit() {
       	int x = 0;
	for (int i = 0; i < dimension; i++) { 
	    for (int j = 0; j <= i; j++) {
		thearray[i][j] = x;
		thearray[j][i] = x;
		x++;
	    }
	}       
    }

    /** 
     * Print the 2-dimensional array. Useful for testing.
     */
    public String toString() {

	StringBuffer sb = new StringBuffer();
	for (int i = 0; i < dimension; i++) { 
	    for (int j = 0; j < dimension; j++) {
		sb.append(Integer.toString(thearray[i][j])+ " ");
	    }
	    sb.append("\n");
	}
	return(sb.toString());
    }
}