Source code: com/ubermq/chord/IntegerChordIdentifier.java

   package com.ubermq.chord;
   
   import java.security.*;
   
   /**
    * A chord identifier that uses a 2^32 size identifier space. This
    * is intended for use with the Java <code>hashCode</code> operation
    * to perform correct object hashing. <P>
    *
   * If stricter hashing is required, a SHA implementation of this
   * identifier interface could be created fairly simply.<P>
   */
  public final class IntegerChordIdentifier
      implements ChordIdentifier
  {
      private int id;
      private static SecureRandom sr = null;
  
      static {
          try
          {
              sr = SecureRandom.getInstance("SHA1PRNG");
          }
          catch (NoSuchAlgorithmException e) {
              e.printStackTrace();
          }
      }
  
      public static final long serialVersionUID = 1L;
  
      /**
       * The default finger table size for this identifier type.
       */
      public static final int INTEGER_FINGER_TABLE_SIZE = 16;
  
      /**
       * Constructs a chord identifier from an integer.
       * @param hashCode the integer hash code.
       */
      IntegerChordIdentifier(int hashCode)
      {
          this.id = hashCode;
      }
  
      /**
       * Constructs a chord identifier from the result
       * of the <code>hashCode</code> method on the
       * given object.
       * @param o an object to produce an identifier for
       */
      IntegerChordIdentifier(Object o)
      {
          this.id = o.hashCode();
      }
  
      /**
       * Generates a pseudo-random identifier.
       */
      IntegerChordIdentifier()
      {
          this.id = sr.nextInt();
      }
  
      private static final ChordIdentifierFactory theFactory = new ChordIdentifierFactory() {
          public ChordIdentifier createRandomIdentifier()
          {
              return new IntegerChordIdentifier();
          }
  
          public ChordIdentifier createIdentifier(Object o)
          {
              return new IntegerChordIdentifier(o);
          }
  
          /**
           * Returns the identifier specified by a given URI.  This
           * can be implementation dependent.
           */
          public ChordIdentifier getIdentifier(java.net.URI uri)
          {
              if (uri.getPath() == null ||
                  uri.getPath().length() == 0)
                  return null;
              else
                  return new IntegerChordIdentifier(Integer.valueOf(uri.getPath().substring(1)).intValue());
          }
  
          public int getFingerTableSize()
          {
              return INTEGER_FINGER_TABLE_SIZE;
          }
      };
  
      /**
       * Returns the chord identifier factory for integer
       * chord identifiers.
       */
      public static ChordIdentifierFactory getFactory()
      {
         return theFactory;
     }
 
     public double normal()
     {
         return ((1 + (((double)id) / Integer.MAX_VALUE)) / 2);
     }
 
     /**
      * Returns the next chord identifier in the
      * identifier sequence.
      *
      * @return a chord identifier that is the next in the
      * identifier sequence.
      */
     public ChordIdentifier next()
     {
         return new IntegerChordIdentifier(id + 1);
     }
 
     /**
      * Returns the chord identifier that is <code>l</code>
      * after this one.
      *
      * @return a chord identifier that is the specified
      * interval away.
      */
     public ChordIdentifier next(long l)
     {
         return new IntegerChordIdentifier(id + (int)(l & 0xffffffff));
     }
 
     /**
      * Returns the identifier for the <code>i</code>th finger
      * for this identifier.  A finger is defined by the Chord
      * set of algorithms as the identifier that succeeds this
      * identifier by 2<super>i</super>. However, individual
      * identifiers can use other finger computations, as appropriate.
      *
      * @param i the finger index, from 1 to <code>factory().getFingerTableSize()-1</code>.
      * The finger at index 0 is defined as the immediate successor to this node.
      * @return the identifier corresponding to the ith finger.
      * @throws IllegalArgumentException if i is out of the specified range
      */
     public ChordIdentifier nextFinger(int i)
     {
         return new IntegerChordIdentifier(id + (1 << i));
     }
 
     /**
      * Returns the previous chord identifier in the
      * identifier sequence.
      *
      * @return a chord identifier that is immediately before this
      * one in the identifier sequence.
      */
     public ChordIdentifier previous()
     {
         return new IntegerChordIdentifier(id - 1);
     }
 
     /**
      * Returns the chord identifier that is <code>l</code>
      * before this one.
      *
      * @return a chord identifier that is the specified
      * interval before this identifier.
      */
     public ChordIdentifier previous(long l)
     {
         return new IntegerChordIdentifier(id - (int)(l & 0xffffffff));
     }
 
     /**
      * Provides the factory instance used to create this
      * identifier, so that new identifiers can be easily
      * created from existing ones.
      * @return an identifier factory
      */
     public ChordIdentifierFactory factory()
     {
         return IntegerChordIdentifier.theFactory;
     }
 
     /**
      * Returns the value of this chord identifier as an <code>int</code>.
      * @return an int representing this identifier
      */
     public int intValue()
     {
         return id;
     }
 
     public int compareTo(Object o)
     {
         IntegerChordIdentifier i = (IntegerChordIdentifier)o;
         return (id == i.id) ? 0 : ((id > i.id) ? 1 : -1);
     }
 
     public boolean equals(Object o)
     {
         if (o instanceof IntegerChordIdentifier)
             return id == ((IntegerChordIdentifier)o).id;
         else return false;
     }
 
     public int hashCode()
     {
         return id;
     }
 
     public String toString()
     {
         return String.valueOf(id);
     }
 }