/*

 * Copyright (c) 1997, 2005, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package java.rmi;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

import java.io.ObjectStreamConstants;

import java.io.OutputStream;

import java.io.Serializable;

import sun.rmi.server.MarshalInputStream;

import sun.rmi.server.MarshalOutputStream;

/**

 * A <code>MarshalledObject</code> contains a byte stream with the serialized

 * representation of an object given to its constructor.  The <code>get</code>

 * method returns a new copy of the original object, as deserialized from

 * the contained byte stream.  The contained object is serialized and

 * deserialized with the same serialization semantics used for marshaling

 * and unmarshaling parameters and return values of RMI calls:  When the

 * serialized form is created:

 *

 * <ul>

 * <li> classes are annotated with a codebase URL from where the class

 *      can be loaded (if available), and

 * <li> any remote object in the <code>MarshalledObject</code> is

 *      represented by a serialized instance of its stub.

 * </ul>

 *

 * <p>When copy of the object is retrieved (via the <code>get</code> method),

 * if the class is not available locally, it will be loaded from the

 * appropriate location (specified the URL annotated with the class descriptor

 * when the class was serialized.

 *

 * <p><code>MarshalledObject</code> facilitates passing objects in RMI calls

 * that are not automatically deserialized immediately by the remote peer.

 *

 * @param <T> the type of the object contained in this

 * <code>MarshalledObject</code>

 *

 * @author  Ann Wollrath

 * @author  Peter Jones

 * @since   1.2

 */

public final class MarshalledObject<T> implements Serializable {

    /**

     * @serial Bytes of serialized representation.  If <code>objBytes</code> is

     * <code>null</code> then the object marshalled was a <code>null</code>

     * reference.

     */

    private byte[] objBytes = null;

    /**

     * @serial Bytes of location annotations, which are ignored by

     * <code>equals</code>.  If <code>locBytes</code> is null, there were no

     * non-<code>null</code> annotations during marshalling.

     */

    private byte[] locBytes = null;

    /**

     * @serial Stored hash code of contained object.

     *

     * @see #hashCode

     */

    private int hash;

    /** Indicate compatibility with 1.2 version of class. */

    private static final long serialVersionUID = 8988374069173025854L;

    /**

     * Creates a new <code>MarshalledObject</code> that contains the

     * serialized representation of the current state of the supplied object.

     * The object is serialized with the semantics used for marshaling

     * parameters for RMI calls.

     *

     * @param obj the object to be serialized (must be serializable)

     * @exception IOException if an <code>IOException</code> occurs; an

     * <code>IOException</code> may occur if <code>obj</code> is not

     * serializable.

     * @since 1.2

     */

    public MarshalledObject(T obj) throws IOException {

        if (obj == null) {

            hash = 13;

            return;

        }

        ByteArrayOutputStream bout = new ByteArrayOutputStream();

        ByteArrayOutputStream lout = new ByteArrayOutputStream();

        MarshalledObjectOutputStream out =

            new MarshalledObjectOutputStream(bout, lout);

        out.writeObject(obj);

        out.flush();

        objBytes = bout.toByteArray();

        // locBytes is null if no annotations

        locBytes = (out.hadAnnotations() ? lout.toByteArray() : null);

        /*

         * Calculate hash from the marshalled representation of object

         * so the hashcode will be comparable when sent between VMs.

         */

        int h = 0;

        for (int i = 0; i < objBytes.length; i++) {

            h = 31 * h + objBytes[i];

        }

        hash = h;

    }

    /**

     * Returns a new copy of the contained marshalledobject.  The internal

     * representation is deserialized with the semantics used for

     * unmarshaling paramters for RMI calls.

     *

     * @return a copy of the contained object

     * @exception IOException if an <code>IOException</code> occurs while

     * deserializing the object from its internal representation.

     * @exception ClassNotFoundException if a

     * <code>ClassNotFoundException</code> occurs while deserializing the

     * object from its internal representation.

     * could not be found

     * @since 1.2

     */

    public T get() throws IOException, ClassNotFoundException {

        if (objBytes == null)   // must have been a null object

            return null;

        ByteArrayInputStream bin = new ByteArrayInputStream(objBytes);

        // locBytes is null if no annotations

        ByteArrayInputStream lin =

            (locBytes == null ? null : new ByteArrayInputStream(locBytes));

        MarshalledObjectInputStream in =

            new MarshalledObjectInputStream(bin, lin);

        T obj = (T) in.readObject();

        in.close();

        return obj;

    }

    /**

     * Return a hash code for this <code>MarshalledObject</code>.

     *

     * @return a hash code

     */

    public int hashCode() {

        return hash;

    }

    /**

     * Compares this <code>MarshalledObject</code> to another object.

     * Returns true if and only if the argument refers to a

     * <code>MarshalledObject</code> that contains exactly the same

     * serialized representation of an object as this one does. The

     * comparison ignores any class codebase annotation, meaning that

     * two objects are equivalent if they have the same serialized

     * representation <i>except</i> for the codebase of each class

     * in the serialized representation.

     *

     * @param obj the object to compare with this <code>MarshalledObject</code>

     * @return <code>true</code> if the argument contains an equaivalent

     * serialized object; <code>false</code> otherwise

     * @since 1.2

     */

    public boolean equals(Object obj) {

        if (obj == this)

            return true;

        if (obj != null && obj instanceof MarshalledObject) {

            MarshalledObject other = (MarshalledObject) obj;

            // if either is a ref to null, both must be

            if (objBytes == null || other.objBytes == null)

                return objBytes == other.objBytes;

            // quick, easy test

            if (objBytes.length != other.objBytes.length)

                return false;

            //!! There is talk about adding an array comparision method

            //!! at 1.2 -- if so, this should be rewritten.  -arnold

            for (int i = 0; i < objBytes.length; ++i) {

                if (objBytes[i] != other.objBytes[i])

                    return false;

            }

            return true;

        } else {

            return false;

        }

    }

    /**

     * This class is used to marshal objects for

     * <code>MarshalledObject</code>.  It places the location annotations

     * to one side so that two <code>MarshalledObject</code>s can be

     * compared for equality if they differ only in location

     * annotations.  Objects written using this stream should be read back

     * from a <code>MarshalledObjectInputStream</code>.

     *

     * @see java.rmi.MarshalledObject

     * @see MarshalledObjectInputStream

     */

    private static class MarshalledObjectOutputStream

        extends MarshalOutputStream

    {

        /** The stream on which location objects are written. */

        private ObjectOutputStream locOut;

        /** <code>true</code> if non-<code>null</code> annotations are

         *  written.

         */

        private boolean hadAnnotations;

        /**

         * Creates a new <code>MarshalledObjectOutputStream</code> whose

         * non-location bytes will be written to <code>objOut</code> and whose

         * location annotations (if any) will be written to

         * <code>locOut</code>.

         */

        MarshalledObjectOutputStream(OutputStream objOut, OutputStream locOut)

            throws IOException

        {

            super(objOut);

            this.useProtocolVersion(ObjectStreamConstants.PROTOCOL_VERSION_2);

            this.locOut = new ObjectOutputStream(locOut);

            hadAnnotations = false;

        }

        /**

         * Returns <code>true</code> if any non-<code>null</code> location

         * annotations have been written to this stream.

         */

        boolean hadAnnotations() {

            return hadAnnotations;

        }

        /**

         * Overrides MarshalOutputStream.writeLocation implementation to write

         * annotations to the location stream.

         */

        protected void writeLocation(String loc) throws IOException {

            hadAnnotations |= (loc != null);

            locOut.writeObject(loc);

        }

        public void flush() throws IOException {

            super.flush();

            locOut.flush();

        }

    }

    /**

     * The counterpart to <code>MarshalledObjectOutputStream</code>.

     *

     * @see MarshalledObjectOutputStream

     */

    private static class MarshalledObjectInputStream

        extends MarshalInputStream

    {

        /**

         * The stream from which annotations will be read.  If this is

         * <code>null</code>, then all annotations were <code>null</code>.

         */

        private ObjectInputStream locIn;

        /**

         * Creates a new <code>MarshalledObjectInputStream</code> that

         * reads its objects from <code>objIn</code> and annotations

         * from <code>locIn</code>.  If <code>locIn</code> is

         * <code>null</code>, then all annotations will be

         * <code>null</code>.

         */

        MarshalledObjectInputStream(InputStream objIn, InputStream locIn)

            throws IOException

        {

            super(objIn);

            this.locIn = (locIn == null ? null : new ObjectInputStream(locIn));

        }

        /**

         * Overrides MarshalInputStream.readLocation to return locations from

         * the stream we were given, or <code>null</code> if we were given a

         * <code>null</code> location stream.

         */

        protected Object readLocation()

            throws IOException, ClassNotFoundException

        {

            return (locIn == null ? null : locIn.readObject());

        }

    }

}