/*

 * Copyright (c) 1996, 2011, 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.server;

import java.io.DataInput;

import java.io.DataOutput;

import java.io.IOException;

import java.io.Serializable;

import java.security.SecureRandom;

/**

 * A <code>UID</code> represents an identifier that is unique over time

 * with respect to the host it is generated on, or one of 2<sup>16</sup>

 * "well-known" identifiers.

 *

 * <p>The {@link #UID()} constructor can be used to generate an

 * identifier that is unique over time with respect to the host it is

 * generated on.  The {@link #UID(short)} constructor can be used to

 * create one of 2<sup>16</sup> well-known identifiers.

 *

 * <p>A <code>UID</code> instance contains three primitive values:

 * <ul>

 * <li><code>unique</code>, an <code>int</code> that uniquely identifies

 * the VM that this <code>UID</code> was generated in, with respect to its

 * host and at the time represented by the <code>time</code> value (an

 * example implementation of the <code>unique</code> value would be a

 * process identifier),

 *  or zero for a well-known <code>UID</code>

 * <li><code>time</code>, a <code>long</code> equal to a time (as returned

 * by {@link System#currentTimeMillis()}) at which the VM that this

 * <code>UID</code> was generated in was alive,

 * or zero for a well-known <code>UID</code>

 * <li><code>count</code>, a <code>short</code> to distinguish

 * <code>UID</code>s generated in the same VM with the same

 * <code>time</code> value

 * </ul>

 *

 * <p>An independently generated <code>UID</code> instance is unique

 * over time with respect to the host it is generated on as long as

 * the host requires more than one millisecond to reboot and its system

 * clock is never set backward.  A globally unique identifier can be

 * constructed by pairing a <code>UID</code> instance with a unique host

 * identifier, such as an IP address.

 *

 * @author      Ann Wollrath

 * @author      Peter Jones

 * @since       1.1

 */

public final class UID implements Serializable {

    private static int hostUnique;

    private static boolean hostUniqueSet = false;

    private static final Object lock = new Object();

    private static long lastTime = System.currentTimeMillis();

    private static short lastCount = Short.MIN_VALUE;

    /** indicate compatibility with JDK 1.1.x version of class */

    private static final long serialVersionUID = 1086053664494604050L;

    /**

     * number that uniquely identifies the VM that this <code>UID</code>

     * was generated in with respect to its host and at the given time

     * @serial

     */

    private final int unique;

    /**

     * a time (as returned by {@link System#currentTimeMillis()}) at which

     * the VM that this <code>UID</code> was generated in was alive

     * @serial

     */

    private final long time;

    /**

     * 16-bit number to distinguish <code>UID</code> instances created

     * in the same VM with the same time value

     * @serial

     */

    private final short count;

    /**

     * Generates a <code>UID</code> that is unique over time with

     * respect to the host that it was generated on.

     */

    public UID() {

        synchronized (lock) {

            if (!hostUniqueSet) {

                hostUnique = (new SecureRandom()).nextInt();

                hostUniqueSet = true;

            }

            unique = hostUnique;

            if (lastCount == Short.MAX_VALUE) {

                boolean interrupted = Thread.interrupted();

                boolean done = false;

                while (!done) {

                    long now = System.currentTimeMillis();

                    if (now == lastTime) {

                        // wait for time to change

                        try {

                            Thread.sleep(1);

                        } catch (InterruptedException e) {

                            interrupted = true;

                        }

                    } else {

                        // If system time has gone backwards increase

                        // original by 1ms to maintain uniqueness

                        lastTime = (now < lastTime) ? lastTime+1 : now;

                        lastCount = Short.MIN_VALUE;

                        done = true;

                    }

                }

                if (interrupted) {

                    Thread.currentThread().interrupt();

                }

            }

            time = lastTime;

            count = lastCount++;

        }

    }

    /**

     * Creates a "well-known" <code>UID</code>.

     *

     * There are 2<sup>16</sup> possible such well-known ids.

     *

     * <p>A <code>UID</code> created via this constructor will not

     * clash with any <code>UID</code>s generated via the no-arg

     * constructor.

     *

     * @param   num number for well-known <code>UID</code>

     */

    public UID(short num) {

        unique = 0;

        time = 0;

        count = num;

    }

    /**

     * Constructs a <code>UID</code> given data read from a stream.

     */

    private UID(int unique, long time, short count) {

        this.unique = unique;

        this.time = time;

        this.count = count;

    }

    /**

     * Returns the hash code value for this <code>UID</code>.

     *

     * @return  the hash code value for this <code>UID</code>

     */

    public int hashCode() {

        return (int) time + (int) count;

    }

    /**

     * Compares the specified object with this <code>UID</code> for

     * equality.

     *

     * This method returns <code>true</code> if and only if the

     * specified object is a <code>UID</code> instance with the same

     * <code>unique</code>, <code>time</code>, and <code>count</code>

     * values as this one.

     *

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

     *

     * @return  <code>true</code> if the given object is equivalent to

     * this one, and <code>false</code> otherwise

     */

    public boolean equals(Object obj) {

        if (obj instanceof UID) {

            UID uid = (UID) obj;

            return (unique == uid.unique &&

                    count == uid.count &&

                    time == uid.time);

        } else {

            return false;

        }

    }

    /**

     * Returns a string representation of this <code>UID</code>.

     *

     * @return  a string representation of this <code>UID</code>

     */

    public String toString() {

        return Integer.toString(unique,16) + ":" +

            Long.toString(time,16) + ":" +

            Integer.toString(count,16);

    }

    /**

     * Marshals a binary representation of this <code>UID</code> to

     * a <code>DataOutput</code> instance.

     *

     * <p>Specifically, this method first invokes the given stream's

     * {@link DataOutput#writeInt(int)} method with this <code>UID</code>'s

     * <code>unique</code> value, then it invokes the stream's

     * {@link DataOutput#writeLong(long)} method with this <code>UID</code>'s

     * <code>time</code> value, and then it invokes the stream's

     * {@link DataOutput#writeShort(int)} method with this <code>UID</code>'s

     * <code>count</code> value.

     *

     * @param   out the <code>DataOutput</code> instance to write

     * this <code>UID</code> to

     *

     * @throws  IOException if an I/O error occurs while performing

     * this operation

     */

    public void write(DataOutput out) throws IOException {

        out.writeInt(unique);

        out.writeLong(time);

        out.writeShort(count);

    }

    /**

     * Constructs and returns a new <code>UID</code> instance by

     * unmarshalling a binary representation from an

     * <code>DataInput</code> instance.

     *

     * <p>Specifically, this method first invokes the given stream's

     * {@link DataInput#readInt()} method to read a <code>unique</code> value,

     * then it invoke's the stream's

     * {@link DataInput#readLong()} method to read a <code>time</code> value,

     * then it invoke's the stream's

     * {@link DataInput#readShort()} method to read a <code>count</code> value,

     * and then it creates and returns a new <code>UID</code> instance

     * that contains the <code>unique</code>, <code>time</code>, and

     * <code>count</code> values that were read from the stream.

     *

     * @param   in the <code>DataInput</code> instance to read

     * <code>UID</code> from

     *

     * @return  unmarshalled <code>UID</code> instance

     *

     * @throws  IOException if an I/O error occurs while performing

     * this operation

     */

    public static UID read(DataInput in) throws IOException {

        int unique = in.readInt();

        long time = in.readLong();

        short count = in.readShort();

        return new UID(unique, time, count);

    }

}