UUID (HyperGraphDB Core 1.3-SNAPSHOT API)

java.lang.Object
- org.hypergraphdb.handle.UUID

All Implemented Interfaces:

Serializable, Cloneable, Comparable<UUID>
```
public class UUID
extends Object
implements Serializable, Cloneable, Comparable<UUID>
```
NOTE - code adapted from JUG libary (Copyright (c) 2002- Tatu Saloranta, tatu.saloranta@iki.fi). See http://jug.safehaus.org/. This code only support type 4 UUID - randomly generated ones.

See Also:
Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`static byte`	`INDEX_CLOCK_HI`
`static byte`	`INDEX_CLOCK_LO`
`static byte`	`INDEX_CLOCK_MID`
`static byte`	`INDEX_CLOCK_SEQUENCE`
`static byte`	`INDEX_TYPE`
`static byte`	`INDEX_VARIATION`
`static String`	`NAMESPACE_DNS`
`static String`	`NAMESPACE_OID`
`static String`	`NAMESPACE_URL`
`static String`	`NAMESPACE_X500`
`static byte`	`TYPE_DCE`
`static byte`	`TYPE_NAME_BASED`
`static byte`	`TYPE_NULL`
`static byte`	`TYPE_RANDOM_BASED`
`static byte`	`TYPE_TIME_BASED`

Constructor Summary

Constructors
Constructor and Description
`UUID()` Default constructor creates a NIL UUID, one that contains all zeroes Note that the clearing of array is actually unnecessary as JVMs are required to clear up the allocated arrays by default.
`UUID(byte[] data)` Constructor for cases where you already have the 16-byte binary representation of the UUID (for example if you save UUIDs binary takes less than half of space string representation takes).
`UUID(byte[] data, int start)` Constructor for cases where you already have the binary representation of the UUID (for example if you save UUIDs binary takes less than half of space string representation takes) in a byte array
`UUID(String id)` Constructor for creating UUIDs from the canonical string representation Note that implementation is optimized for speed, not necessarily code clarity...

Method Summary

Methods
Modifier and Type	Method and Description
`byte[]`	`asByteArray()` Returns the UUID as a 16-byte byte array
`Object`	`clone()` Default cloning behaviour (bitwise copy) is just fine...
`int`	`compareTo(UUID o)`
`boolean`	`equals(Object o)` Checking equality of UUIDs is easy; just compare the 128-bit number.
`static UUID`	`getNullUUID()` Accessor for getting the shared null UUID
`int`	`getType()` Returns the UUID type code
`int`	`hashCode()`
`boolean`	`isNullUUID()`
`byte[]`	`toByteArray()` 'Synonym' for 'asByteArray'
`void`	`toByteArray(byte[] dst)`
`void`	`toByteArray(byte[] dst, int pos)` Fills in the 16 bytes (from index pos) of the specified byte array with the UUID contents.
`String`	`toString()`
`static UUID`	`valueOf(byte[] src)` Constructs a new UUID instance given a byte array that contains the (16 byte) binary representation.
`static UUID`	`valueOf(byte[] src, int start)` Constructs a new UUID instance given a byte array that contains the (16 byte) binary representation.
`static UUID`	`valueOf(String id)` Constructs a new UUID instance given the canonical string representation of an UUID.

Methods inherited from class java.lang.Object
finalize, getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - INDEX_CLOCK_HI
```
public static final byte INDEX_CLOCK_HI
```
    See Also:
    Constant Field Values
  - INDEX_CLOCK_MID
```
public static final byte INDEX_CLOCK_MID
```
    See Also:
    Constant Field Values
  - INDEX_CLOCK_LO
```
public static final byte INDEX_CLOCK_LO
```
    See Also:
    Constant Field Values
  - INDEX_TYPE
```
public static final byte INDEX_TYPE
```
    See Also:
    Constant Field Values
  - INDEX_CLOCK_SEQUENCE
```
public static final byte INDEX_CLOCK_SEQUENCE
```
    See Also:
    Constant Field Values
  - INDEX_VARIATION
```
public static final byte INDEX_VARIATION
```
    See Also:
    Constant Field Values
  - TYPE_NULL
```
public static final byte TYPE_NULL
```
    See Also:
    Constant Field Values
  - TYPE_TIME_BASED
```
public static final byte TYPE_TIME_BASED
```
    See Also:
    Constant Field Values
  - TYPE_DCE
```
public static final byte TYPE_DCE
```
    See Also:
    Constant Field Values
  - TYPE_NAME_BASED
```
public static final byte TYPE_NAME_BASED
```
    See Also:
    Constant Field Values
  - TYPE_RANDOM_BASED
```
public static final byte TYPE_RANDOM_BASED
```
    See Also:
    Constant Field Values
  - NAMESPACE_DNS
```
public static final String NAMESPACE_DNS
```
    See Also:
    Constant Field Values
  - NAMESPACE_URL
```
public static final String NAMESPACE_URL
```
    See Also:
    Constant Field Values
  - NAMESPACE_OID
```
public static final String NAMESPACE_OID
```
    See Also:
    Constant Field Values
  - NAMESPACE_X500
```
public static final String NAMESPACE_X500
```
    See Also:
    Constant Field Values
- Constructor Detail
  - UUID
```
public UUID()
```
    Default constructor creates a NIL UUID, one that contains all zeroes Note that the clearing of array is actually unnecessary as JVMs are required to clear up the allocated arrays by default.
  - UUID
```
public UUID(byte[] data)
```
    Constructor for cases where you already have the 16-byte binary representation of the UUID (for example if you save UUIDs binary takes less than half of space string representation takes).
    
    Parameters:
    data - array that contains the binary representation of UUID
  - UUID
```
public UUID(byte[] data,
    int start)
```
    Constructor for cases where you already have the binary representation of the UUID (for example if you save UUIDs binary takes less than half of space string representation takes) in a byte array
    
    Parameters:
    data - array that contains the binary representation of UUID
    start - byte offset where UUID starts
  - UUID
```
public UUID(String id)
     throws NumberFormatException
```
    Constructor for creating UUIDs from the canonical string representation Note that implementation is optimized for speed, not necessarily code clarity... Also, since what we get might not be 100% canonical (see below), let's not yet populate mDesc here.
    
    Parameters:
    id - String that contains the canonical representation of the UUID to build; 36-char string (see UUID specs for details). Hex-chars may be in upper-case too; UUID class will always output them in lowercase.
    
    Throws:
    
    NumberFormatException
- Method Detail
  - clone
```
public Object clone()
```
    Default cloning behaviour (bitwise copy) is just fine... Could clear out cached string presentation, but there's probably no point in doing that.
    
    Overrides:
    
    clone in class Object
  - getNullUUID
```
public static UUID getNullUUID()
```
    Accessor for getting the shared null UUID
    
    Returns:
    the shared null UUID
  - isNullUUID
```
public boolean isNullUUID()
```
  - getType
```
public int getType()
```
    Returns the UUID type code
    
    Returns:
    UUID type
  - asByteArray
```
public byte[] asByteArray()
```
    Returns the UUID as a 16-byte byte array
    
    Returns:
    16-byte byte array that contains UUID bytes in the network byte order
  - toByteArray
```
public void toByteArray(byte[] dst,
               int pos)
```
    Fills in the 16 bytes (from index pos) of the specified byte array with the UUID contents.
    
    Parameters:
    dst - Byte array to fill
    pos - Offset in the array
  - toByteArray
```
public void toByteArray(byte[] dst)
```
  - toByteArray
```
public byte[] toByteArray()
```
    'Synonym' for 'asByteArray'
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - compareTo
```
public int compareTo(UUID o)
```
    Specified by:
    
    compareTo in interface Comparable<UUID>
  - equals
```
public boolean equals(Object o)
```
    Checking equality of UUIDs is easy; just compare the 128-bit number.
    
    Overrides:
    
    equals in class Object
  - valueOf
```
public static UUID valueOf(String id)
                    throws NumberFormatException
```
    Constructs a new UUID instance given the canonical string representation of an UUID. Note that calling this method returns the same result as would using the matching (1 string arg) constructor.
    
    Parameters:
    id - Canonical string representation used for constructing an UUID instance
    
    Throws:
    
    NumberFormatException - if 'id' is invalid UUID
  - valueOf
```
public static UUID valueOf(byte[] src,
           int start)
```
    Constructs a new UUID instance given a byte array that contains the (16 byte) binary representation. Note that calling this method returns the same result as would using the matching constructor
    
    Parameters:
    src - Byte array that contains the UUID definition
    start - Offset in the array where the UUID starts
  - valueOf
```
public static UUID valueOf(byte[] src)
```
    Constructs a new UUID instance given a byte array that contains the (16 byte) binary representation. Note that calling this method returns the same result as would using the matching constructor
    
    Parameters:
    src - Byte array that contains the UUID definition

Class UUID

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

INDEX_CLOCK_HI

INDEX_CLOCK_MID

INDEX_CLOCK_LO

INDEX_TYPE

INDEX_CLOCK_SEQUENCE

INDEX_VARIATION

TYPE_NULL

TYPE_TIME_BASED

TYPE_DCE

TYPE_NAME_BASED

TYPE_RANDOM_BASED

NAMESPACE_DNS

NAMESPACE_URL

NAMESPACE_OID

NAMESPACE_X500

Constructor Detail

UUID

UUID

UUID

UUID

Method Detail

clone

getNullUUID

isNullUUID

getType

asByteArray

toByteArray

toByteArray

toByteArray

hashCode

toString

compareTo

equals

valueOf

valueOf

valueOf