Blame | Last modification | View Log | RSS feed
/* Cassandra-compilant MAP v0.1.7 | Adapted by jcoc611 | Based on the following: *//*! JSON v3.3.2 | http://bestiejs.github.io/json3 | Copyright 2012-2014, Kit Cambridge | http://kit.mit-license.org */(function () {// Detect the `define` function exposed by asynchronous module loaders. The// strict `define` check is necessary for compatibility with `r.js`.var isLoader = typeof define === "function" && define.amd;// A set of types used to distinguish objects from primitives.var objectTypes = {"function": true,"object": true};// Detect the `exports` object exposed by CommonJS implementations.var freeExports = objectTypes[typeof exports] && exports && !exports.nodeType && exports;// Use the `global` object exposed by Node (including Browserify via// `insert-module-globals`), Narwhal, and Ringo as the default context,// and the `window` object in browsers. Rhino exports a `global` function// instead.var root = objectTypes[typeof window] && window || this,freeGlobal = freeExports && objectTypes[typeof module] && module && !module.nodeType && typeof global == "object" && global;if (freeGlobal && (freeGlobal["global"] === freeGlobal || freeGlobal["window"] === freeGlobal || freeGlobal["self"] === freeGlobal)) {root = freeGlobal;}// Public: Initializes JSON 3 using the given `context` object, attaching the// `stringify` and `parse` functions to the specified `exports` object.function runInContext(context, exports){context || (context = root["Object"]());exports || (exports = root["Object"]());// Native constructor aliases.var Number = context["Number"] || root["Number"],String = context["String"] || root["String"],Object = context["Object"] || root["Object"],Date = context["Date"] || root["Date"],SyntaxError = context["SyntaxError"] || root["SyntaxError"],TypeError = context["TypeError"] || root["TypeError"],Math = context["Math"] || root["Math"],nativeJSON = context["JSON"] || root["JSON"];// Delegate to the native `stringify` and `parse` implementations.if (typeof nativeJSON == "object" && nativeJSON) {exports.stringify = nativeJSON.stringify;exports.parse = nativeJSON.parse;}// Convenience aliases.var objectProto = Object.prototype,getClass = objectProto.toString,isProperty, forEach, undef;// Test the `Date#getUTC*` methods. Based on work by @Yaffle.var isExtended = new Date(-3509827334573292);try { isExtended = isExtended.getUTCFullYear() == -109252 && isExtended.getUTCMonth() === 0 && isExtended.getUTCDate() === 1 && isExtended.getUTCHours() == 10 && isExtended.getUTCMinutes() == 37 && isExtended.getUTCSeconds() == 6 && isExtended.getUTCMilliseconds() == 708}catch(exception){}// Internal: Determines whether the native `JSON.stringify` and `parse`// implementations are spec-compliant. Based on work by Ken Snyder.// Internal: Determines whether the native `JSON.stringify` and `parse`// implementations are spec-compliant. Based on work by Ken Snyder.function has(name) {if (has[name] !== undef) {// Return cached feature test result.return has[name];}var isSupported;if (name == "bug-string-char-index") {// IE <= 7 doesn't support accessing string characters using square// bracket notation. IE 8 only supports this for primitives.isSupported = "a"[0] != "a";// Do not use JSON as default.} else isSupported = false;return has[name] = !!isSupported;}// Common `[[Class]]` name aliases.var functionClass = "[object Function]",dateClass = "[object Date]",numberClass = "[object Number]",stringClass = "[object String]",arrayClass = "[object Array]",booleanClass = "[object Boolean]";// Detect incomplete support for accessing string characters by index.var charIndexBuggy = has("bug-string-char-index");// Define additional utility methods if the `Date` methods are buggy.if (!isExtended) {var floor = Math.floor;// A mapping between the months of the year and the number of days between// January 1st and the first of the respective month.var Months = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334];// Internal: Calculates the number of days between the Unix epoch and the// first day of the given month.var getDay = function (year, month) {return Months[month] + 365 * (year - 1970) + floor((year - 1969 + (month = +(month > 1))) / 4) - floor((year - 1901 + month) / 100) + floor((year - 1601 + month) / 400);};}// Internal: Determines if a property is a direct property of the given// object. Delegates to the native `Object#hasOwnProperty` method.if (!(isProperty = objectProto.hasOwnProperty)) {isProperty = function (property) {var members = {}, constructor;if ((members.__proto__ = null, members.__proto__ = {// The *proto* property cannot be set multiple times in recent// versions of Firefox and SeaMonkey."toString": 1}, members).toString != getClass) {// Safari <= 2.0.3 doesn't implement `Object#hasOwnProperty`, but// supports the mutable *proto* property.isProperty = function (property) {// Capture and break the object's prototype chain (see section 8.6.2// of the ES 5.1 spec). The parenthesized expression prevents an// unsafe transformation by the Closure Compiler.var original = this.__proto__, result = property in (this.__proto__ = null, this);// Restore the original prototype chain.this.__proto__ = original;return result;};} else {// Capture a reference to the top-level `Object` constructor.constructor = members.constructor;// Use the `constructor` property to simulate `Object#hasOwnProperty` in// other environments.isProperty = function (property) {var parent = (this.constructor || constructor).prototype;return property in this && !(property in parent && this[property] === parent[property]);};}members = null;return isProperty.call(this, property);};}// Internal: Normalizes the `for...in` iteration algorithm across// environments. Each enumerated key is yielded to a `callback` function.forEach = function (object, callback) {var size = 0, Properties, members, property;// Tests for bugs in the current environment's `for...in` algorithm. The// `valueOf` property inherits the non-enumerable flag from// `Object.prototype` in older versions of IE, Netscape, and Mozilla.(Properties = function () {this.valueOf = 0;}).prototype.valueOf = 0;// Iterate over a new instance of the `Properties` class.members = new Properties();for (property in members) {// Ignore all properties inherited from `Object.prototype`.if (isProperty.call(members, property)) {size++;}}Properties = members = null;// Normalize the iteration algorithm.if (!size) {// A list of non-enumerable properties inherited from `Object.prototype`.members = ["valueOf", "toString", "toLocaleString", "propertyIsEnumerable", "isPrototypeOf", "hasOwnProperty", "constructor"];// IE <= 8, Mozilla 1.0, and Netscape 6.2 ignore shadowed non-enumerable// properties.forEach = function (object, callback) {var isFunction = getClass.call(object) == functionClass, property, length;var hasProperty = !isFunction && typeof object.constructor != "function" && objectTypes[typeof object.hasOwnProperty] && object.hasOwnProperty || isProperty;for (property in object) {// Gecko <= 1.0 enumerates the `prototype` property of functions under// certain conditions; IE does not.if (!(isFunction && property == "prototype") && hasProperty.call(object, property)) {callback(property);}}// Manually invoke the callback for each non-enumerable property.for (length = members.length; property = members[--length]; hasProperty.call(object, property) && callback(property));};} else if (size == 2) {// Safari <= 2.0.4 enumerates shadowed properties twice.forEach = function (object, callback) {// Create a set of iterated properties.var members = {}, isFunction = getClass.call(object) == functionClass, property;for (property in object) {// Store each property name to prevent double enumeration. The// `prototype` property of functions is not enumerated due to cross-// environment inconsistencies.if (!(isFunction && property == "prototype") && !isProperty.call(members, property) && (members[property] = 1) && isProperty.call(object, property)) {callback(property);}}};} else {// No bugs detected; use the standard `for...in` algorithm.forEach = function (object, callback) {var isFunction = getClass.call(object) == functionClass, property, isConstructor;for (property in object) {if (!(isFunction && property == "prototype") && isProperty.call(object, property) && !(isConstructor = property === "constructor")) {callback(property);}}// Manually invoke the callback for the `constructor` property due to// cross-environment inconsistencies.if (isConstructor || isProperty.call(object, (property = "constructor"))) {callback(property);}};}return forEach(object, callback);};// Public: Serializes a JavaScript `value` as a JSON string. The optional// `filter` argument may specify either a function that alters how object and// array members are serialized, or an array of strings and numbers that// indicates which properties should be serialized. The optional `width`// argument may be either a string or number that specifies the indentation// level of the output.// Internal: A map of control characters and their escaped equivalents.// [Cassandra]: uses single quotes.var Escapes = {92: "\\\\",//34: '\\" ',39: "\\'", // single quote escape8: "\\b",12: "\\f",10: "\\n",13: "\\r",9: "\\t"};// Internal: Converts `value` into a zero-padded string such that its// length is at least equal to `width`. The `width` must be <= 6.var leadingZeroes = "000000";var toPaddedString = function (width, value) {// The `|| 0` expression is necessary to work around a bug in// Opera <= 7.54u2 where `0 == -0`, but `String(-0) !== "0"`.return (leadingZeroes + (value || 0)).slice(-width);};// Internal: Double-quotes a string `value`, replacing all ASCII control// characters (characters with code unit values between 0 and 31) with// their escaped equivalents. This is an implementation of the// `Quote(value)` operation defined in ES 5.1 section 15.12.3.var unicodePrefix = "\\u00";var quote = function (value) {var result = "'", index = 0, length = value.length, useCharIndex = !charIndexBuggy || length > 10;var symbols = useCharIndex && (charIndexBuggy ? value.split("") : value);for (; index < length; index++) {var charCode = value.charCodeAt(index);// If the character is a control character, append its Unicode or// shorthand escape sequence; otherwise, append the character as-is.switch (charCode) {case 8: case 9: case 10: case 12: case 13: case 39: case 92:result += Escapes[charCode];break;default:if (charCode < 32) {result += unicodePrefix + toPaddedString(2, charCode.toString(16));break;}result += useCharIndex ? symbols[index] : value.charAt(index);}}return result + "'";};// Internal: Recursively serializes an object. Implements the// `Str(key, holder)`, `JO(value)`, and `JA(value)` operations.var serialize = function (property, object, callback, properties, whitespace, indentation, stack) {var value, className, year, month, date, time, hours, minutes, seconds, milliseconds, results, element, index, length, prefix, result;try {// Necessary for host object support.value = object[property];} catch (exception) {}if (typeof value == "object" && value) {className = getClass.call(value);if (className == dateClass && !isProperty.call(value, "toJSON")) {if (value > -1 / 0 && value < 1 / 0) {// Dates are serialized according to the `Date#toJSON` method// specified in ES 5.1 section 15.9.5.44. See section 15.9.1.15// for the ISO 8601 date time string format.if (getDay) {// Manually compute the year, month, date, hours, minutes,// seconds, and milliseconds if the `getUTC*` methods are// buggy. Adapted from @Yaffle's `date-shim` project.date = floor(value / 864e5);for (year = floor(date / 365.2425) + 1970 - 1; getDay(year + 1, 0) <= date; year++);for (month = floor((date - getDay(year, 0)) / 30.42); getDay(year, month + 1) <= date; month++);date = 1 + date - getDay(year, month);// The `time` value specifies the time within the day (see ES// 5.1 section 15.9.1.2). The formula `(A % B + B) % B` is used// to compute `A modulo B`, as the `%` operator does not// correspond to the `modulo` operation for negative numbers.time = (value % 864e5 + 864e5) % 864e5;// The hours, minutes, seconds, and milliseconds are obtained by// decomposing the time within the day. See section 15.9.1.10.hours = floor(time / 36e5) % 24;minutes = floor(time / 6e4) % 60;seconds = floor(time / 1e3) % 60;milliseconds = time % 1e3;} else {year = value.getUTCFullYear();month = value.getUTCMonth();date = value.getUTCDate();hours = value.getUTCHours();minutes = value.getUTCMinutes();seconds = value.getUTCSeconds();milliseconds = value.getUTCMilliseconds();}// Serialize extended years correctly.value = (year <= 0 || year >= 1e4 ? (year < 0 ? "-" : "+") + toPaddedString(6, year < 0 ? -year : year) : toPaddedString(4, year)) +"-" + toPaddedString(2, month + 1) + "-" + toPaddedString(2, date) +// Months, dates, hours, minutes, and seconds should have two// digits; milliseconds should have three."T" + toPaddedString(2, hours) + ":" + toPaddedString(2, minutes) + ":" + toPaddedString(2, seconds) +// Milliseconds are optional in ES 5.0, but required in 5.1."." + toPaddedString(3, milliseconds) + "Z";} else {value = null;}} else if (typeof value.toJSON == "function" && ((className != numberClass && className != stringClass && className != arrayClass) || isProperty.call(value, "toJSON"))) {// Prototype <= 1.6.1 adds non-standard `toJSON` methods to the// `Number`, `String`, `Date`, and `Array` prototypes. JSON 3// ignores all `toJSON` methods on these objects unless they are// defined directly on an instance.value = value.toJSON(property);}}if (callback) {// If a replacement function was provided, call it to obtain the value// for serialization.value = callback.call(object, property, value);}if (value === null) {return "null";}className = getClass.call(value);if (className == booleanClass) {// Booleans are represented literally.return "" + value;} else if (className == numberClass) {// JSON numbers must be finite. `Infinity` and `NaN` are serialized as// `"null"`.return value > -1 / 0 && value < 1 / 0 ? "" + value : "null";} else if (className == stringClass) {// Strings are double-quoted and escaped.return quote("" + value);}// Recursively serialize objects and arrays.if (typeof value == "object") {// Check for cyclic structures. This is a linear search; performance// is inversely proportional to the number of unique nested objects.for (length = stack.length; length--;) {if (stack[length] === value) {// Cyclic structures cannot be serialized by `JSON.stringify`.throw TypeError();}}// Add the object to the stack of traversed objects.stack.push(value);results = [];// Save the current indentation level and indent one additional level.prefix = indentation;indentation += whitespace;if (className == arrayClass) {// Recursively serialize array elements.for (index = 0, length = value.length; index < length; index++) {element = serialize(index, value, callback, properties, whitespace, indentation, stack);results.push(element === undef ? "null" : element);}result = results.length ? (whitespace ? "[\n" + indentation + results.join(",\n" + indentation) + "\n" + prefix + "]" : ("[" + results.join(",") + "]")) : "[]";} else {// Recursively serialize object members. Members are selected from// either a user-specified list of property names, or the object// itself.forEach(properties || value, function (property) {var element = serialize(property, value, callback, properties, whitespace, indentation, stack);if (element !== undef) {// According to ES 5.1 section 15.12.3: "If `gap` {whitespace}// is not the empty string, let `member` {quote(property) + ":"}// be the concatenation of `member` and the `space` character."// The "`space` character" refers to the literal space// character, not the `space` {width} argument provided to// `JSON.stringify`.results.push(quote(property) + ":" + (whitespace ? " " : "") + element);}});result = results.length ? (whitespace ? "{\n" + indentation + results.join(",\n" + indentation) + "\n" + prefix + "}" : ("{" + results.join(",") + "}")) : "{}";}// Remove the object from the traversed object stack.stack.pop();return result;}};// Public: `JSON.stringify`. See ES 5.1 section 15.12.3.exports.stringify = function (source, filter, width) {var whitespace, callback, properties, className;if (objectTypes[typeof filter] && filter) {if ((className = getClass.call(filter)) == functionClass) {callback = filter;} else if (className == arrayClass) {// Convert the property names array into a makeshift set.properties = {};for (var index = 0, length = filter.length, value; index < length; value = filter[index++], ((className = getClass.call(value)), className == stringClass || className == numberClass) && (properties[value] = 1));}}if (width) {if ((className = getClass.call(width)) == numberClass) {// Convert the `width` to an integer and create a string containing// `width` number of space characters.if ((width -= width % 1) > 0) {for (whitespace = "", width > 10 && (width = 10); whitespace.length < width; whitespace += " ");}} else if (className == stringClass) {whitespace = width.length <= 10 ? width : width.slice(0, 10);}}// Opera <= 7.54u2 discards the values associated with empty string keys// (`""`) only if they are used directly within an object member list// (e.g., `!("" in { "": 1})`).return serialize("", (value = {}, value[""] = source, value), callback, properties, whitespace, "", []);};// Public: Parses a JSON source string.var fromCharCode = String.fromCharCode;// Internal: A map of escaped control characters and their unescaped// equivalents.var Unescapes = {92: "\\",// 34: '"',39: "'", // single quote47: "/",98: "\b",116: "\t",110: "\n",102: "\f",114: "\r"};// Internal: Stores the parser state.var Index, Source;// Internal: Resets the parser state and throws a `SyntaxError`.var abort = function () {Index = Source = null;throw SyntaxError();};// Internal: Returns the next token, or `"$"` if the parser has reached// the end of the source string. A token may be a string, number, `null`// literal, or Boolean literal.var lex = function () {var source = Source, length = source.length, value, begin, position, isSigned, charCode;while (Index < length) {charCode = source.charCodeAt(Index);switch (charCode) {case 9: case 10: case 13: case 32:// Skip whitespace tokens, including tabs, carriage returns, line// feeds, and space characters.Index++;break;case 123: case 125: case 91: case 93: case 58: case 44:// Parse a punctuator token (`{`, `}`, `[`, `]`, `:`, or `,`) at// the current position.value = charIndexBuggy ? source.charAt(Index) : source[Index];Index++;return value;case 39:// `'` delimits a MAP string; advance to the next character and// begin parsing the string. String tokens are prefixed with the// sentinel `@` character to distinguish them from punctuators and// end-of-string tokens.for (value = "@", Index++; Index < length;) {charCode = source.charCodeAt(Index);if (charCode < 32) {// Unescaped ASCII control characters (those with a code unit// less than the space character) are not permitted.abort();} else if (charCode == 92) {// A reverse solidus (`\`) marks the beginning of an escaped// control character (including `"`, `\`, and `/`) or Unicode// escape sequence.charCode = source.charCodeAt(++Index);switch (charCode) {case 92: case 39: case 47: case 98: case 116: case 110: case 102: case 114:// Revive escaped control characters.value += Unescapes[charCode];Index++;break;case 117:// `\u` marks the beginning of a Unicode escape sequence.// Advance to the first character and validate the// four-digit code point.begin = ++Index;for (position = Index + 4; Index < position; Index++) {charCode = source.charCodeAt(Index);// A valid sequence comprises four hexdigits (case-// insensitive) that form a single hexadecimal value.if (!(charCode >= 48 && charCode <= 57 || charCode >= 97 && charCode <= 102 || charCode >= 65 && charCode <= 70)) {// Invalid Unicode escape sequence.abort();}}// Revive the escaped character.value += fromCharCode("0x" + source.slice(begin, Index));break;default:// Invalid escape sequence.abort();}} else {if (charCode == 39) {// An unescaped double-quote character marks the end of the// string.break;}charCode = source.charCodeAt(Index);begin = Index;// Optimize for the common case where a string is valid.while (charCode >= 32 && charCode != 92 && charCode != 39) {charCode = source.charCodeAt(++Index);}// Append the string as-is.value += source.slice(begin, Index);}}if (source.charCodeAt(Index) == 39) {// Advance to the next character and return the revived string.Index++;return value;}// Unterminated string.abort();default:// Parse numbers and literals.begin = Index;// Advance past the negative sign, if one is specified.if (charCode == 45) {isSigned = true;charCode = source.charCodeAt(++Index);}// Parse an integer or floating-point value.if (charCode >= 48 && charCode <= 57) {// Leading zeroes are interpreted as octal literals.if (charCode == 48 && ((charCode = source.charCodeAt(Index + 1)), charCode >= 48 && charCode <= 57)) {// Illegal octal literal.abort();}isSigned = false;// Parse the integer component.for (; Index < length && ((charCode = source.charCodeAt(Index)), charCode >= 48 && charCode <= 57); Index++);// Floats cannot contain a leading decimal point; however, this// case is already accounted for by the parser.if (source.charCodeAt(Index) == 46) {position = ++Index;// Parse the decimal component.for (; position < length && ((charCode = source.charCodeAt(position)), charCode >= 48 && charCode <= 57); position++);if (position == Index) {// Illegal trailing decimal.abort();}Index = position;}// Parse exponents. The `e` denoting the exponent is// case-insensitive.charCode = source.charCodeAt(Index);if (charCode == 101 || charCode == 69) {charCode = source.charCodeAt(++Index);// Skip past the sign following the exponent, if one is// specified.if (charCode == 43 || charCode == 45) {Index++;}// Parse the exponential component.for (position = Index; position < length && ((charCode = source.charCodeAt(position)), charCode >= 48 && charCode <= 57); position++);if (position == Index) {// Illegal empty exponent.abort();}Index = position;}// Coerce the parsed value to a JavaScript number.return +source.slice(begin, Index);}// A negative sign may only precede numbers.if (isSigned) {abort();}// `true`, `false`, and `null` literals.if (source.slice(Index, Index + 4) == "true") {Index += 4;return true;} else if (source.slice(Index, Index + 5) == "false") {Index += 5;return false;} else if (source.slice(Index, Index + 4) == "null") {Index += 4;return null;}// Unrecognized token.abort();}}// Return the sentinel `$` character if the parser has reached the end// of the source string.return "$";};// Internal: Parses a JSON `value` token.var get = function (value) {var results, hasMembers;if (value == "$") {// Unexpected end of input.abort();}if (typeof value == "string") {if ((charIndexBuggy ? value.charAt(0) : value[0]) == "@") {// Remove the sentinel `@` character.return value.slice(1);}// Parse object and array literals.if (value == "[") {// Parses a JSON array, returning a new JavaScript array.results = [];for (;; hasMembers || (hasMembers = true)) {value = lex();// A closing square bracket marks the end of the array literal.if (value == "]") {break;}// If the array literal contains elements, the current token// should be a comma separating the previous element from the// next.if (hasMembers) {if (value == ",") {value = lex();if (value == "]") {// Unexpected trailing `,` in array literal.abort();}} else {// A `,` must separate each array element.abort();}}// Elisions and leading commas are not permitted.if (value == ",") {abort();}results.push(get(value));}return results;} else if (value == "{") {// Parses a JSON object, returning a new JavaScript object.results = {};for (;; hasMembers || (hasMembers = true)) {value = lex();// A closing curly brace marks the end of the object literal.if (value == "}") {break;}// If the object literal contains members, the current token// should be a comma separator.if (hasMembers) {if (value == ",") {value = lex();if (value == "}") {// Unexpected trailing `,` in object literal.abort();}} else {// A `,` must separate each object member.abort();}}// Leading commas are not permitted, object property names must be// double-quoted strings, and a `:` must separate each property// name and value.if (value == "," || typeof value != "string" || (charIndexBuggy ? value.charAt(0) : value[0]) != "@" || lex() != ":") {abort();}results[value.slice(1)] = get(lex());}return results;}// Unexpected token encountered.abort();}return value;};// Internal: Updates a traversed object member.var update = function (source, property, callback) {var element = walk(source, property, callback);if (element === undef) {delete source[property];} else {source[property] = element;}};// Internal: Recursively traverses a parsed JSON object, invoking the// `callback` function for each value. This is an implementation of the// `Walk(holder, name)` operation defined in ES 5.1 section 15.12.2.var walk = function (source, property, callback) {var value = source[property], length;if (typeof value == "object" && value) {// `forEach` can't be used to traverse an array in Opera <= 8.54// because its `Object#hasOwnProperty` implementation returns `false`// for array indices (e.g., `![1, 2, 3].hasOwnProperty("0")`).if (getClass.call(value) == arrayClass) {for (length = value.length; length--;) {update(value, length, callback);}} else {forEach(value, function (property) {update(value, property, callback);});}}return callback.call(source, property, value);};// Public: `JSON.parse`. See ES 5.1 section 15.12.2.exports.parse = function (source, callback) {var result, value;Index = 0;Source = "" + source;result = get(lex());// If a JSON string contains multiple tokens, it is invalid.if (lex() != "$") {abort();}// Reset the parser state.Index = Source = null;return callback && getClass.call(callback) == functionClass ? walk((value = {}, value[""] = result, value), "", callback) : result;};exports["runInContext"] = runInContext;return exports;};// Creates an object and returns it with the .stringify, .parse, and .runInContextroot["cassandraMAP"] = {};runInContext(root, freeExports||root["cassandraMAP"]);}).call(this);