| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| package flex.messaging.util; |
| |
| import java.util.Random; |
| import java.util.UUID; |
| |
| public class UUIDUtils |
| { |
| private static Random _weakRand = new Random(); |
| |
| /** |
| * The spec indicates that our time value should be based on 100 nano |
| * second increments but our time granularity is in milliseconds. |
| * The spec also says we can approximate the time by doing an increment |
| * when we dole out new ids in the same millisecond. We can fit 10,000 |
| * 100 nanos into a single millisecond. |
| */ |
| private static final int MAX_IDS_PER_MILLI = 10000; |
| |
| /** |
| * Any given time-of-day value can only be used once; remember the last used |
| * value so we don't reuse them. |
| * <p>NOTE: this algorithm assumes the clock will not be turned back. |
| */ |
| private static long lastUsedTOD = 0; |
| /** Counter to use when we need more than one id in the same millisecond. */ |
| private static int numIdsThisMilli = 0; |
| |
| /** Hex digits, used for padding UUID strings with random characters. */ |
| private static final String alphaNum = "0123456789ABCDEF"; |
| |
| /** 4 bits per hex character. */ |
| private static final int BITS_PER_DIGIT = 4; |
| |
| private static final int BITS_PER_INT = 32; |
| private static final int BITS_PER_LONG = 64; |
| private static final int DIGITS_PER_INT = BITS_PER_INT / BITS_PER_DIGIT; |
| private static final int DIGITS_PER_LONG = BITS_PER_LONG / BITS_PER_DIGIT; |
| |
| /** |
| * @private |
| */ |
| private static char[] UPPER_DIGITS = new char[] { |
| '0', '1', '2', '3', '4', '5', '6', '7', |
| '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', |
| }; |
| |
| /** |
| * Private constructor to prevent instances from being created. |
| */ |
| private UUIDUtils() |
| { |
| } |
| |
| /** |
| * |
| * Use the createUUID function when you need a unique string that you will |
| * use as a persistent identifier in a distributed environment. To a very |
| * high degree of certainty, this function returns a unique value; no other |
| * invocation on the same or any other system should return the same value. |
| * |
| * @return a Universally Unique Identifier (UUID) |
| * Proper Format: `XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX' |
| * where `X' stands for a hexadecimal digit (0-9 or A-F). |
| */ |
| public static String createUUID() |
| { |
| return createUUID(false); |
| } |
| |
| public static String createUUID(boolean secure) throws Error |
| { |
| Random rand = _weakRand; |
| if (secure) |
| throw new Error("Secure UUIDs not implemented"); |
| |
| StringBuffer s = new StringBuffer(36); |
| |
| appendHexString(uniqueTOD(), false, 11, s); |
| |
| // Just use random padding characters, but ensure that the high bit |
| // is set to eliminate chances of collision with an IEEE 802 address. |
| s.append( alphaNum.charAt( rand.nextInt(16) | 8 ) ); |
| |
| // Add random padding characters. |
| appendRandomHexChars(32 - s.length(), rand, s); |
| |
| //insert dashes in proper position. so the format matches CF |
| s.insert(8,"-"); |
| s.insert(13,"-"); |
| s.insert(18,"-"); |
| s.insert(23,"-"); |
| |
| return s.toString(); |
| } |
| |
| /** |
| * Converts a 128-bit UID encoded as a byte[] to a String representation. |
| * The format matches that generated by createUID. If a suitable byte[] |
| * is not provided, null is returned. |
| * |
| * @param ba byte[] 16 bytes in length representing a 128-bit UID. |
| * |
| * @return String representation of the UID, or null if an invalid |
| * byte[] is provided. |
| */ |
| public static String fromByteArray(byte[] ba) |
| { |
| if (ba == null || ba.length != 16) |
| return null; |
| |
| StringBuffer result = new StringBuffer(36); |
| for (int i = 0; i < 16; i++) |
| { |
| if (i == 4 || i == 6 || i == 8 || i == 10) |
| result.append('-'); |
| |
| result.append(UPPER_DIGITS[(ba[i] & 0xF0) >>> 4]); |
| result.append(UPPER_DIGITS[(ba[i] & 0x0F)]); |
| } |
| return result.toString(); |
| } |
| |
| |
| /** |
| * A utility method to check whether a String value represents a |
| * correctly formatted UID value. UID values are expected to be |
| * in the format generated by createUID(), implying that only |
| * capitalized A-F characters in addition to 0-9 digits are |
| * supported. |
| * |
| * @param uid The value to test whether it is formatted as a UID. |
| * |
| * @return Returns true if the value is formatted as a UID. |
| */ |
| public static boolean isUID(String uid) |
| { |
| if (uid == null || uid.length() != 36) |
| return false; |
| |
| char[] chars = uid.toCharArray(); |
| for (int i = 0; i < 36; i++) |
| { |
| char c = chars[i]; |
| |
| // Check for correctly placed hyphens |
| if (i == 8 || i == 13 || i == 18 || i == 23) |
| { |
| if (c != '-') |
| return false; |
| } |
| // We allow capital alpha-numeric hex digits only |
| else if (c < 48 || c > 70 || (c > 57 && c < 65)) |
| { |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| |
| /** |
| * Converts a UID formatted String to a byte[]. The UID must be in the |
| * format generated by createUID, otherwise null is returned. |
| * |
| * @param uid String representing a 128-bit UID. |
| * |
| * @return byte[] 16 bytes in length representing the 128-bits of the |
| * UID or null if the uid could not be converted. |
| */ |
| public static byte[] toByteArray(String uid) |
| { |
| if (!isUID(uid)) |
| return null; |
| |
| byte[] result = new byte[16]; |
| char[] chars = uid.toCharArray(); |
| int r = 0; |
| |
| for (int i = 0; i < chars.length; i++) |
| { |
| if (chars[i] == '-') |
| continue; |
| int h1 = Character.digit(chars[i], 16); |
| i++; |
| int h2 = Character.digit(chars[i], 16); |
| result[r++] = (byte)(((h1 << 4) | h2) & 0xFF); |
| } |
| return result; |
| } |
| |
| private static void appendRandomHexChars(int n, Random rand, StringBuffer result) |
| { |
| int digitsPerInt = DIGITS_PER_INT; |
| while (n > 0) |
| { |
| int digitsToUse = Math.min(n, digitsPerInt); |
| n -= digitsToUse; |
| appendHexString(rand.nextInt(), true, digitsToUse, result); |
| } |
| } |
| |
| private static void appendHexString |
| (long value, boolean prependZeroes, int nLeastSignificantDigits, |
| StringBuffer result) |
| { |
| int bitsPerDigit = BITS_PER_DIGIT; |
| |
| long mask = (1L << bitsPerDigit) - 1; |
| |
| if (nLeastSignificantDigits < DIGITS_PER_LONG) |
| { |
| // Clear the bits that we don't care about. |
| value &= (1L << (bitsPerDigit * nLeastSignificantDigits)) - 1; |
| } |
| |
| // Reorder the sequence so that the first set of bits will become the |
| // last set of bits. |
| int i = 0; |
| long reorderedValue = 0; |
| if (value == 0) |
| { |
| // One zero is dumped. |
| i++; |
| } |
| else |
| { |
| do |
| { |
| reorderedValue = (reorderedValue << bitsPerDigit) | (value & mask); |
| value >>>= bitsPerDigit; |
| i++; |
| } while (value != 0); |
| } |
| |
| if (prependZeroes) |
| { |
| for (int j = nLeastSignificantDigits - i; j > 0; j--) |
| { |
| result.append('0'); |
| } |
| } |
| |
| |
| // Dump the reordered sequence, with the most significant character |
| // first. |
| for (; i > 0; i--) |
| { |
| result.append(alphaNum.charAt((int) (reorderedValue & mask))); |
| reorderedValue >>>= bitsPerDigit; |
| } |
| } |
| |
| private static String createInsecureUUID() |
| { |
| StringBuffer s = new StringBuffer(36); |
| |
| appendHexString(uniqueTOD(), false, 11, s); |
| |
| // Just use random padding characters, but ensure that the high bit |
| // is set to eliminate chances of collision with an IEEE 802 address. |
| s.append( alphaNum.charAt( _weakRand.nextInt(16) | 8 ) ); |
| |
| // Add random padding characters. |
| appendRandomHexChars(32 - s.length(), _weakRand, s); |
| |
| //insert dashes in proper position. so the format matches CF |
| s.insert(8,"-"); |
| s.insert(13,"-"); |
| s.insert(18,"-"); |
| s.insert(23,"-"); |
| |
| return s.toString(); |
| } |
| |
| /** |
| * @return a time value, unique for calls to this method loaded by the same classloader. |
| */ |
| private static synchronized long uniqueTOD() |
| { |
| long currentTOD = System.currentTimeMillis(); |
| |
| // Clock was set back... do not hang in this case waiting to catch up. |
| // Instead, rely on the random number part to differentiate the ids. |
| if (currentTOD < lastUsedTOD) |
| lastUsedTOD = currentTOD; |
| |
| if (currentTOD == lastUsedTOD) |
| { |
| numIdsThisMilli++; |
| /* |
| * Fall back to the old technique of sleeping if we allocate |
| * too many ids in one time interval. |
| */ |
| if (numIdsThisMilli >= MAX_IDS_PER_MILLI) |
| { |
| while ( currentTOD == lastUsedTOD ) |
| { |
| try { Thread.sleep(1); } catch ( Exception interrupt ) { /* swallow, wake up */ } |
| currentTOD = System.currentTimeMillis(); |
| } |
| lastUsedTOD = currentTOD; |
| numIdsThisMilli = 0; |
| } |
| } |
| else |
| { |
| // We have a new TOD, reset the counter |
| lastUsedTOD = currentTOD; |
| numIdsThisMilli = 0; |
| } |
| |
| return lastUsedTOD * MAX_IDS_PER_MILLI + (long)numIdsThisMilli; |
| } |
| } |
