Included are methods to create a Uuid with a given
* 128-bit value or a string representation of such a value, to
* generate new Uuid values, and to read a binary
* representation of a Uuid from a stream.
*
*
* @since 2.0
**/
public final class UuidFactory {
/** guards secureRandom */
private static final Object lock = new Object();
/** source of cryptographically strong random bits, lazily created */
private static SecureRandom secureRandom;
/**
* Creates a new Uuid with the specified 128-bit
* value.
*
*
This method can be used to create a Uuid with a
* value that has been previously generated, perhaps by an
* external mechanism.
*
* @param bits0 the most significant 64 bits of the 128-bit value
*
* @param bits1 the least significant 64 bits of the 128-bit value
*
* @return a Uuid with the given value
**/
public static Uuid create(long bits0, long bits1) {
return new Impl(bits0, bits1);
}
/**
* Creates a new Uuid with the 128-bit value
* represented by the specified string.
*
*
The supplied string representation must be in the format
* defined by {@link Uuid#toString Uuid.toString} except that
* uppercase hexadecimal digits are allowed.
*
* @param s the string representation to create the
* Uuid with
*
* @return a Uuid with the value represented by the
* given string
*
* @throws IllegalArgumentException if the supplied string
* representation does not conform to the specified format
*
* @throws NullPointerException if s is
* null
**/
public static Uuid create(String s) {
if (s.length() != 36 ||
s.charAt(8) != '-' ||
s.charAt(13) != '-' ||
s.charAt(18) != '-' ||
s.charAt(23) != '-')
{
throw new IllegalArgumentException(
"invalid string representation: \"" + s + "\"");
}
long time_low;
long time_mid;
long time_hi_and_version;
long clock_seq_and_variant;
long node;
try {
time_low = Long.parseLong(s.substring(0, 8), 16);
time_mid = Long.parseLong(s.substring(9, 13), 16);
time_hi_and_version = Long.parseLong(s.substring(14, 18), 16);
clock_seq_and_variant = Long.parseLong(s.substring(19, 23), 16);
node = Long.parseLong(s.substring(24, 36), 16);
} catch (NumberFormatException e) {
IllegalArgumentException iae = new IllegalArgumentException(
"invalid string representation: \"" + s + "\"");
iae.initCause(e);
throw iae;
}
if (time_low < 0 ||
time_mid < 0 ||
time_hi_and_version < 0 ||
clock_seq_and_variant < 0 ||
node < 0)
{
throw new IllegalArgumentException(
"invalid string representation: \"" + s + "\"");
}
long bits0 = time_low << 32 | time_mid << 16 | time_hi_and_version;
long bits1 = clock_seq_and_variant << 48 | node;
return create(bits0, bits1);
}
/**
* Generates a new Uuid with 122 bits of its value
* produced from a cryptographically strong random sequence.
*
*
The value of a Uuid returned by this method is
* computationally difficult to guess and is highly likely to be
* unique with respect to all other Uuid values
* returned by this method over space and time.
*
*
Specifically, this method creates a new Uuid
* with the a variant field of 0x2, a
* version field of 0x4, and the
* remaining 122 bits of its value produced from a
* cryptographically strong random sequence.
*
* @return a newly generated Uuid
*
* @see SecureRandom
**/
public static Uuid generate() {
synchronized (lock) {
if (secureRandom == null) {
secureRandom = new SecureRandom();
}
}
long bits0 = secureRandom.nextLong();
long bits1 = secureRandom.nextLong();
// set "version" field to 0x4
bits0 &= 0xFFFFFFFFFFFF0FFFL;
bits0 |= 0x0000000000004000L;
// set "variant" field to 0x2
bits1 &= 0x3FFFFFFFFFFFFFFFL;
bits1 |= 0x8000000000000000L;
return create(bits0, bits1);
}
/**
* Creates a new Uuid with the 128-bit value obtained
* by unmarshalling a binary representation from the supplied
* InputStream.
*
*
Specifically, this method reads 16 bytes from the stream,
* and then it creates a new Uuid with the 128-bit
* value represented by those bytes interpreted in network
* (big-endian) byte order.
*
* @param in the InputStream to read the
* Uuid from
*
* @return a Uuid with the value unmarshalled from
* the stream
*
* @throws IOException if an I/O exception occurs while performing
* this operation
*
* @throws NullPointerException if in is
* null
**/
public static Uuid read(InputStream in) throws IOException {
long bits0 = readLong(in);
long bits1 = readLong(in);
return create(bits0, bits1);
}
/**
* Read a long value from an InputStream in big-endian byte order.
**/
private static long readLong(InputStream in) throws IOException {
int b0 = in.read();
int b1 = in.read();
int b2 = in.read();
int b3 = in.read();
if ((b0 | b1 | b2 | b3) == -1) {
throw new EOFException();
}
int upper = (b0 << 24) | (b1 << 16) | (b2 << 8) | b3;
b0 = in.read();
b1 = in.read();
b2 = in.read();
b3 = in.read();
if ((b0 | b1 | b2 | b3) == -1) {
throw new EOFException();
}
int lower = (b0 << 24) | (b1 << 16) | (b2 << 8) | b3;
return ((long) upper << 32) | (lower & 0xFFFFFFFFL);
}
/** Prevents instantiation. */
private UuidFactory() { throw new AssertionError(); }
/**
* Extends Uuid trivially, in order to be a preferred
* class and retain the original codebase annotation.
**/
private static class Impl extends Uuid {
private static final long serialVersionUID = 1089722863511468966L;
Impl(long bits0, long bits1) {
super(bits0, bits1);
}
}
}