From e44a7e37b6c7b5961adaffc62b9042b8d442938e Mon Sep 17 00:00:00 2001 From: mensonge Date: Thu, 13 Nov 2008 09:49:11 +0000 Subject: New feature: basic Ajax suggestion for tags and implementation of Dojo toolkit git-svn-id: https://semanticscuttle.svn.sourceforge.net/svnroot/semanticscuttle/trunk@151 b3834d28-1941-0410-a4f8-b48e95affb8f --- includes/js/dojox/uuid/_base.js | 245 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 245 insertions(+) create mode 100644 includes/js/dojox/uuid/_base.js (limited to 'includes/js/dojox/uuid/_base.js') diff --git a/includes/js/dojox/uuid/_base.js b/includes/js/dojox/uuid/_base.js new file mode 100644 index 0000000..b65e5da --- /dev/null +++ b/includes/js/dojox/uuid/_base.js @@ -0,0 +1,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; + } +}; + +} -- cgit v1.2.3-54-g00ecf