Coverage Report - org.apache.commons.id.uuid.state.Node
 
Classes in this File Line Coverage Branch Coverage Complexity
Node
78%
25/32
40%
4/10
1.778
 
 1   
 /*
 2   
  * Licensed to the Apache Software Foundation (ASF) under one or more
 3   
  * contributor license agreements.  See the NOTICE file distributed with
 4   
  * this work for additional information regarding copyright ownership.
 5   
  * The ASF licenses this file to You under the Apache License, Version 2.0
 6   
  * (the "License"); you may not use this file except in compliance with
 7   
  * the License.  You may obtain a copy of the License at
 8   
  *
 9   
  *      http://www.apache.org/licenses/LICENSE-2.0
 10   
  *
 11   
  * Unless required by applicable law or agreed to in writing, software
 12   
  * distributed under the License is distributed on an "AS IS" BASIS,
 13   
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 14   
  * See the License for the specific language governing permissions and
 15   
  * limitations under the License.
 16   
  */
 17   
 
 18   
 package org.apache.commons.id.uuid.state;
 19   
 
 20   
 import java.util.Arrays;
 21   
 
 22   
 import org.apache.commons.id.uuid.clock.Clock;
 23   
 import org.apache.commons.id.uuid.clock.OverClockedException;
 24   
 
 25   
 
 26   
 /**
 27   
  * <p>The <code>Node</code> class represents the data and accessors for a single
 28   
  * node identifier. The node id is generally the IEEE 802 address, the clock
 29   
  * sequence, and last timestamp generated are all attributes of a node that need
 30   
  * to be maintained.</p>
 31   
  *
 32   
  * @author Commons-Id team
 33   
  * @version $Id: Node.java 480488 2006-11-29 08:57:26Z bayard $
 34   
  */
 35   
 public class Node {
 36   
 
 37   
     /** The node identifier bytes this class represents. */
 38   
     private byte[] id;
 39   
 
 40   
     /** The clock sequence associated with this node. */
 41   
     private short clockSequence;
 42   
 
 43   
     /** The last time stamp used. */
 44   
     private long lastTimestamp;
 45   
 
 46   
     /** The Clock implementation instance for this Node. */
 47   
     private Clock clock;
 48   
 
 49   
     /**
 50   
      * <p>Constructor used to create a <node>Node</node> when the lastTimestamp
 51   
      * and clock sequence are unavailable.</p>
 52   
      *
 53   
      * @param   nodeId the byte array representing this nodes identifier.
 54   
      *          Usually the  IEEE 802 address bytes.
 55   
      */
 56  10 
     public Node(byte[] nodeId) {
 57  10 
         id = nodeId;
 58  10 
         clockSequence = StateHelper.newClockSequence();
 59  10 
         clock = StateHelper.getClockImpl();
 60  10 
     }
 61   
 
 62   
     /**
 63   
      * <p>Constructor used to create a <node>Node</node> when all persistent state
 64   
      * information is available; node bytes, lastTimestamp, and clock sequence.
 65   
      * </p>
 66   
      *
 67   
      * @param   nodeId the byte array representing this nodes identifier.
 68   
      *          Usually the  IEEE 802 address bytes.
 69   
      * @param   lastTime the last timestamp this <code>Node</code> used.
 70   
      * @param   clockSeq the last clock sequence used in generation from this node.
 71   
      */
 72  16 
     public Node(byte[] nodeId, long lastTime, short clockSeq) {
 73  16 
         id = nodeId;
 74  16 
         lastTimestamp = lastTime;
 75  16 
         clockSequence = clockSeq;
 76  16 
         clock = StateHelper.getClockImpl();
 77  16 
     }
 78   
 
 79   
     /**
 80   
      * <p>Returns the node identifier bytes for this node.</p>
 81   
      *
 82   
      * @return the node identifier bytes for this node.
 83   
      */
 84   
 
 85   
     public byte[] getNodeIdentifier() {
 86  32 
         return id;
 87   
     }
 88   
 
 89   
     /**
 90   
      * <p>Returns the clock sequence used in this node.</p>
 91   
      *
 92   
      * @return the clock sequence used in this node.
 93   
      */
 94   
     public short getClockSequence() {
 95  14 
         return clockSequence;
 96   
     }
 97   
 
 98   
     /**
 99   
      * <p>Increments the clock sequence in this node.</p>
 100   
      */
 101   
     private void incrementClockSequence() {
 102   
         //Increment, but if it's greater than its 14-bits, reset it
 103  0 
         if (++clockSequence > 0x3FFF) {
 104  0 
             clockSequence = 0;
 105   
         }
 106  0 
     }
 107   
 
 108   
     /**
 109   
      * <p>Returns the time in UUID time.</p>
 110   
      *
 111   
      * @return the time in UUID time.
 112   
      * @throws OverClockedException the max number of timestamps generated in
 113   
      * this interval has been exceeded.
 114   
      */
 115   
     public long getUUIDTime() throws OverClockedException {
 116  4 
         long newTime = clock.getUUIDTime();
 117  4 
         if (newTime <= lastTimestamp) {
 118  0 
             incrementClockSequence();
 119   
         }
 120  4 
         lastTimestamp = newTime;
 121  4 
         return newTime;
 122   
     }
 123   
 
 124   
     /**
 125   
      * <p>Returns true if the identifier value in this Node is equal to the
 126   
      * identifier value in the compare to Node.</p>
 127   
      *
 128   
      * @param compareTo the Node to compare for equivalence.
 129   
      * @return true if the two node's identifiers are equal; otherwise false.
 130   
      * @see Object#equals
 131   
      */
 132   
     public boolean equals(Object compareTo) {
 133  18 
         if (compareTo instanceof Node) {
 134  18 
             byte[] comp = ((Node) compareTo).getNodeIdentifier();
 135  18 
             return Arrays.equals(comp, this.id);
 136  0 
         } else if (compareTo instanceof byte[]) {
 137  0 
             return Arrays.equals((byte[]) compareTo, id);
 138   
         }
 139  0 
         return false;
 140   
     }
 141   
 
 142   
     /**
 143   
      * @see Object#hashCode
 144   
      */
 145   
     public int hashCode() {
 146  16 
         int hash = 0;
 147  112 
         for (int i = 0; i < id.length; i++) {
 148  96 
             hash += id[i];
 149   
         }
 150  16 
         return hash;
 151   
     }
 152   
     /**
 153   
      * <p>Returns the last uuid timestamp from this <code>Node</code>.</p>
 154   
      *
 155   
      * @return the last uuid timestamp from this Node.
 156   
      */
 157   
     public long getLastTimestamp() {
 158  25 
         return lastTimestamp;
 159   
     }
 160   
 
 161   
 }
Report generated by Cobertura 1.9 on 17/05/08 17:21.