1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
|
if(!dojo._hasResource["dojox.uuid._base"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
dojo._hasResource["dojox.uuid._base"] = true;
dojo.provide("dojox.uuid._base");
// Public constants:
dojox.uuid.NIL_UUID = "00000000-0000-0000-0000-000000000000";
dojox.uuid.version = {
// Enumeration for the different UUID versions.
UNKNOWN: 0,
TIME_BASED: 1,
DCE_SECURITY: 2,
NAME_BASED_MD5: 3,
RANDOM: 4,
NAME_BASED_SHA1: 5 };
dojox.uuid.variant = {
// Enumeration for the different UUID variants.
NCS: "0",
DCE: "10",
MICROSOFT: "110",
UNKNOWN: "111" };
dojox.uuid.assert = function(/*Boolean*/ booleanValue, /*String?*/ message){
// summary:
// Throws an exception if the assertion fails.
// description:
// If the asserted condition is true, this method does nothing. If the
// condition is false, we throw an error with a error message.
// booleanValue: Must be true for the assertion to succeed.
// message: A string describing the assertion.
// throws: Throws an Error if 'booleanValue' is false.
if(!booleanValue){
if(!message){
message = "An assert statement failed.\n" +
"The method dojox.uuid.assert() was called with a 'false' value.\n";
}
throw new Error(message);
}
};
dojox.uuid.generateNilUuid = function(){
// summary:
// This function returns the Nil UUID: "00000000-0000-0000-0000-000000000000".
// description:
// The Nil UUID is described in section 4.1.7 of
// RFC 4122: http://tools.ietf.org/html/rfc4122#section-4.1.7
// examples:
// var string = dojox.uuid.generateNilUuid();
return dojox.uuid.NIL_UUID;; // String
};
dojox.uuid.isValid = function(/*String*/ uuidString){
// summary:
// Returns true if the UUID was initialized with a valid value.
uuidString = uuidString.toString();
var valid = (dojo.isString(uuidString) &&
(uuidString.length == 36) &&
(uuidString == uuidString.toLowerCase()));
if(valid){
var arrayOfParts = uuidString.split("-");
valid = ((arrayOfParts.length == 5) &&
(arrayOfParts[0].length == 8) &&
(arrayOfParts[1].length == 4) &&
(arrayOfParts[2].length == 4) &&
(arrayOfParts[3].length == 4) &&
(arrayOfParts[4].length == 12));
var HEX_RADIX = 16;
for (var i in arrayOfParts) {
var part = arrayOfParts[i];
var integer = parseInt(part, HEX_RADIX);
valid = valid && isFinite(integer);
}
}
return valid; // boolean
};
dojox.uuid.getVariant = function(/*String*/ uuidString){
// summary:
// Returns a variant code that indicates what type of UUID this is.
// Returns one of the enumerated dojox.uuid.variant values.
// example:
// var variant = dojox.uuid.getVariant("3b12f1df-5232-4804-897e-917bf397618a");
// dojox.uuid.assert(variant == dojox.uuid.variant.DCE);
// example:
// "3b12f1df-5232-4804-897e-917bf397618a"
// ^
// |
// (variant "10__" == DCE)
if(!dojox.uuid._ourVariantLookupTable){
var variant = dojox.uuid.variant;
var lookupTable = [];
lookupTable[0x0] = variant.NCS; // 0000
lookupTable[0x1] = variant.NCS; // 0001
lookupTable[0x2] = variant.NCS; // 0010
lookupTable[0x3] = variant.NCS; // 0011
lookupTable[0x4] = variant.NCS; // 0100
lookupTable[0x5] = variant.NCS; // 0101
lookupTable[0x6] = variant.NCS; // 0110
lookupTable[0x7] = variant.NCS; // 0111
lookupTable[0x8] = variant.DCE; // 1000
lookupTable[0x9] = variant.DCE; // 1001
lookupTable[0xA] = variant.DCE; // 1010
lookupTable[0xB] = variant.DCE; // 1011
lookupTable[0xC] = variant.MICROSOFT; // 1100
lookupTable[0xD] = variant.MICROSOFT; // 1101
lookupTable[0xE] = variant.UNKNOWN; // 1110
lookupTable[0xF] = variant.UNKNOWN; // 1111
dojox.uuid._ourVariantLookupTable = lookupTable;
}
uuidString = uuidString.toString();
var variantCharacter = uuidString.charAt(19);
var HEX_RADIX = 16;
var variantNumber = parseInt(variantCharacter, HEX_RADIX);
dojox.uuid.assert((variantNumber >= 0) && (variantNumber <= 16));
return dojox.uuid._ourVariantLookupTable[variantNumber]; // dojox.uuid.variant
};
dojox.uuid.getVersion = function(/*String*/ uuidString){
// summary:
// Returns a version number that indicates what type of UUID this is.
// Returns one of the enumerated dojox.uuid.version values.
// example:
// var version = dojox.uuid.getVersion("b4308fb0-86cd-11da-a72b-0800200c9a66");
// dojox.uuid.assert(version == dojox.uuid.version.TIME_BASED);
// exceptions:
// Throws an Error if this is not a DCE Variant UUID.
var errorMessage = "dojox.uuid.getVersion() was not passed a DCE Variant UUID.";
dojox.uuid.assert(dojox.uuid.getVariant(uuidString) == dojox.uuid.variant.DCE, errorMessage);
uuidString = uuidString.toString();
// "b4308fb0-86cd-11da-a72b-0800200c9a66"
// ^
// |
// (version 1 == TIME_BASED)
var versionCharacter = uuidString.charAt(14);
var HEX_RADIX = 16;
var versionNumber = parseInt(versionCharacter, HEX_RADIX);
return versionNumber; // dojox.uuid.version
};
dojox.uuid.getNode = function(/*String*/ uuidString){
// summary:
// If this is a version 1 UUID (a time-based UUID), getNode() returns a
// 12-character string with the "node" or "pseudonode" portion of the UUID,
// which is the rightmost 12 characters.
// exceptions:
// Throws an Error if this is not a version 1 UUID.
var errorMessage = "dojox.uuid.getNode() was not passed a TIME_BASED UUID.";
dojox.uuid.assert(dojox.uuid.getVersion(uuidString) == dojox.uuid.version.TIME_BASED, errorMessage);
uuidString = uuidString.toString();
var arrayOfStrings = uuidString.split('-');
var nodeString = arrayOfStrings[4];
return nodeString; // String (a 12-character string, which will look something like "917bf397618a")
};
dojox.uuid.getTimestamp = function(/*String*/ uuidString, /*String?*/ returnType){
// summary:
// If this is a version 1 UUID (a time-based UUID), this method returns
// the timestamp value encoded in the UUID. The caller can ask for the
// timestamp to be returned either as a JavaScript Date object or as a
// 15-character string of hex digits.
// returnType: Any of these five values: "string", String, "hex", "date", Date
// returns:
// Returns the timestamp value as a JavaScript Date object or a 15-character string of hex digits.
// examples:
// var uuidString = "b4308fb0-86cd-11da-a72b-0800200c9a66";
// var date, string, hexString;
// date = dojox.uuid.getTimestamp(uuidString); // returns a JavaScript Date
// date = dojox.uuid.getTimestamp(uuidString, Date); //
// string = dojox.uuid.getTimestamp(uuidString, String); // "Mon, 16 Jan 2006 20:21:41 GMT"
// hexString = dojox.uuid.getTimestamp(uuidString, "hex"); // "1da86cdb4308fb0"
// exceptions:
// Throws an Error if this is not a version 1 UUID.
var errorMessage = "dojox.uuid.getTimestamp() was not passed a TIME_BASED UUID.";
dojox.uuid.assert(dojox.uuid.getVersion(uuidString) == dojox.uuid.version.TIME_BASED, errorMessage);
uuidString = uuidString.toString();
if(!returnType){returnType = null};
switch(returnType){
case "string":
case String:
return dojox.uuid.getTimestamp(uuidString, Date).toUTCString(); // String (e.g. "Mon, 16 Jan 2006 20:21:41 GMT")
break;
case "hex":
// Return a 15-character string of hex digits containing the
// timestamp for this UUID, with the high-order bits first.
var arrayOfStrings = uuidString.split('-');
var hexTimeLow = arrayOfStrings[0];
var hexTimeMid = arrayOfStrings[1];
var hexTimeHigh = arrayOfStrings[2];
// Chop off the leading "1" character, which is the UUID
// version number for time-based UUIDs.
hexTimeHigh = hexTimeHigh.slice(1);
var timestampAsHexString = hexTimeHigh + hexTimeMid + hexTimeLow;
dojox.uuid.assert(timestampAsHexString.length == 15);
return timestampAsHexString; // String (e.g. "1da86cdb4308fb0")
break;
case null: // no returnType was specified, so default to Date
case "date":
case Date:
// Return a JavaScript Date object.
var GREGORIAN_CHANGE_OFFSET_IN_HOURS = 3394248;
var HEX_RADIX = 16;
var arrayOfParts = uuidString.split('-');
var timeLow = parseInt(arrayOfParts[0], HEX_RADIX);
var timeMid = parseInt(arrayOfParts[1], HEX_RADIX);
var timeHigh = parseInt(arrayOfParts[2], HEX_RADIX);
var hundredNanosecondIntervalsSince1582 = timeHigh & 0x0FFF;
hundredNanosecondIntervalsSince1582 <<= 16;
hundredNanosecondIntervalsSince1582 += timeMid;
// What we really want to do next is shift left 32 bits, but the
// result will be too big to fit in an int, so we'll multiply by 2^32,
// and the result will be a floating point approximation.
hundredNanosecondIntervalsSince1582 *= 0x100000000;
hundredNanosecondIntervalsSince1582 += timeLow;
var millisecondsSince1582 = hundredNanosecondIntervalsSince1582 / 10000;
// Again, this will be a floating point approximation.
// We can make things exact later if we need to.
var secondsPerHour = 60 * 60;
var hoursBetween1582and1970 = GREGORIAN_CHANGE_OFFSET_IN_HOURS;
var secondsBetween1582and1970 = hoursBetween1582and1970 * secondsPerHour;
var millisecondsBetween1582and1970 = secondsBetween1582and1970 * 1000;
var millisecondsSince1970 = millisecondsSince1582 - millisecondsBetween1582and1970;
var timestampAsDate = new Date(millisecondsSince1970);
return timestampAsDate; // Date
break;
default:
// we got passed something other than a valid returnType
dojox.uuid.assert(false, "dojox.uuid.getTimestamp was not passed a valid returnType: " + returnType);
break;
}
};
}
|
