home *** CD-ROM | disk | FTP | other *** search
/ Chip 1998 November / Chip_1998-11_cd.bin / tema / Cafe / main.bin / UID.java < prev    next >
Text File  |  1997-05-20  |  4KB  |  151 lines
  1. /*
  2.  * @(#)UID.java    1.4 96/11/18
  3.  * 
  4.  * Copyright (c) 1995, 1996 Sun Microsystems, Inc. All Rights Reserved.
  5.  * 
  6.  * This software is the confidential and proprietary information of Sun
  7.  * Microsystems, Inc. ("Confidential Information").  You shall not
  8.  * disclose such Confidential Information and shall use it only in
  9.  * accordance with the terms of the license agreement you entered into
  10.  * with Sun.
  11.  * 
  12.  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
  13.  * SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  14.  * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
  15.  * PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
  16.  * SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
  17.  * THIS SOFTWARE OR ITS DERIVATIVES.
  18.  * 
  19.  * CopyrightVersion 1.1_beta
  20.  */
  21. package java.rmi.server;
  22.  
  23. import java.io.*;
  24.  
  25. /**
  26.  * Abstraction for creating identifiers that are unique with respect
  27.  * to the the host on which it is generated.
  28.  */
  29. public final class UID implements java.io.Serializable {
  30.     private int unique;
  31.     private long time;
  32.     private short count;
  33.  
  34.     /**
  35.      * In the absence of an actual pid, just do something somewhat
  36.      * random.
  37.      */
  38.     private static int getHostUniqueNum() {
  39.     return (new Object()).hashCode();
  40.     }
  41.     
  42.     private static int hostUnique = getHostUniqueNum();
  43.     private static long lastTime = System.currentTimeMillis();
  44.     private static short lastCount = Short.MIN_VALUE;
  45.     private static Object mutex = new Object();
  46.     private static long  ONE_SECOND = 1000; // in milliseconds
  47.     
  48.     /**
  49.      * Create a pure identifier that is unique with respect to the
  50.      * host on which it is generated.  This UID is unique under the
  51.      * following conditions: a) the machine takes more than one second
  52.      * to reboot, and b) the machine's clock is never set backward.
  53.      * In order to construct a UID that is globally unique, simply
  54.      * pair a UID with an InetAddress.
  55.      */
  56.     public UID() {
  57.     
  58.     synchronized (mutex) {
  59.         if (lastCount == Short.MAX_VALUE) {
  60.         boolean done = false;
  61.         while (!done) {
  62.             time = System.currentTimeMillis();
  63.             if (time < lastTime+ONE_SECOND) {
  64.             // pause for a second to wait for time to change
  65.             try {
  66.                 Thread.currentThread().sleep(ONE_SECOND);
  67.             } catch (java.lang.InterruptedException e) {
  68.             }    // ignore exception
  69.             continue;
  70.             } else {
  71.             lastTime = time;
  72.             lastCount = Short.MIN_VALUE;
  73.             done = true;
  74.             }
  75.         }
  76.         } else {
  77.         time = lastTime;
  78.         }
  79.         unique = hostUnique;
  80.         count = lastCount++;
  81.     }
  82.     }
  83.  
  84.     /**
  85.      * Create a "well-known" ID.  There are 2^16 -1 such possible
  86.      * well-known ids.  An id generated via this constructor will not
  87.      * clash with any id generated via the default UID
  88.      * constructor which will generates a genuinely unique identifier
  89.      * with respect to this host.
  90.      */
  91.     public UID(short num) 
  92.     {
  93.     unique = 0;
  94.     time = 0;
  95.     count = num;
  96.     }
  97.  
  98.     private UID(int unique, long time, short count) 
  99.     {
  100.     this.unique = unique;
  101.     this.time = time;
  102.     this.count = count;
  103.     }
  104.  
  105.     public int hashCode() {
  106.     return (int)time + (int)count;
  107.     }
  108.  
  109.     public boolean equals(Object obj) {
  110.     if ((obj != null) && (obj instanceof UID)) {
  111.         UID uid = (UID)obj;
  112.         return (unique == uid.unique &&
  113.             count == uid.count &&
  114.             time == uid.time);
  115.     } else {
  116.         return false;
  117.     }
  118.     }
  119.     
  120.     public String toString() {
  121.     return Integer.toString(unique,16) + ":" +
  122.         Long.toString(time,16) + ":" +
  123.         Integer.toString(count,16);
  124.     }
  125.     
  126.     /**
  127.      * Write uid to output stream.
  128.      */
  129.     public void write(DataOutput out) throws java.io.IOException
  130.     {
  131.     out.writeInt(unique);
  132.     out.writeLong(time);
  133.     out.writeShort(count);
  134.     }
  135.     
  136.     /**
  137.      * Get the uid from the input stream.
  138.      * @param in the input stream
  139.      * @exception IOException If uid could not be read
  140.      * (due to stream failure or malformed uid)
  141.      */
  142.     public static UID read(DataInput in)
  143.     throws java.io.IOException
  144.     {
  145.     int unique = in.readInt();
  146.     long time = in.readLong();
  147.     short count = in.readShort();
  148.     return new UID(unique, time, count);
  149.     }
  150. }
  151.