com.cognitect.transit.impl.decoder.js Maven / Gradle / Ivy
// Copyright 2014 Cognitect. All Rights Reserved.
//
// Licensed 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.
goog.provide("com.cognitect.transit.impl.decoder");
goog.require("com.cognitect.transit.util");
goog.require("com.cognitect.transit.delimiters");
goog.require("com.cognitect.transit.caching");
goog.require("com.cognitect.transit.types");
goog.scope(function () {
var decoder = com.cognitect.transit.impl.decoder,
util = com.cognitect.transit.util,
d = com.cognitect.transit.delimiters,
caching = com.cognitect.transit.caching,
types = com.cognitect.transit.types;
// =========================================================================
// Decoder
/**
* @constructor
*/
decoder.Tag = function Transit$Tag(s) {
this.str = s;
};
decoder.tag = function (s) {
return new decoder.Tag(s);
};
decoder.isTag = function (x) {
return x && (x instanceof decoder.Tag);
};
decoder.isGroundHandler = function (handler) {
switch (handler) {
case "_":
case "s":
case "?":
case "i":
case "d":
case "b":
case "'":
case "array":
case "map":
return true;
}
return false;
};
/**
* A transit decoder
* @constructor
*/
decoder.Decoder = function Transit$Decoder(options) {
this.options = options || {};
this.handlers = {};
for (var h in this.defaults.handlers) {
this.handlers[h] = this.defaults.handlers[h];
}
for (var h in this.options["handlers"]) {
if (decoder.isGroundHandler(h)) {
throw new Error("Cannot override handler for ground type \"" + h + "\"");
}
this.handlers[h] = this.options["handlers"][h];
}
this.preferStrings = this.options["preferStrings"] != null ? this.options["preferStrings"] : this.defaults.preferStrings;
this.preferBuffers = this.options["preferBuffers"] != null ? this.options["preferBuffers"] : this.defaults.preferBuffers;
this.defaultHandler = this.options["defaultHandler"] || this.defaults.defaultHandler;
/* NOT PUBLIC */
this.mapBuilder = this.options["mapBuilder"];
this.arrayBuilder = this.options["arrayBuilder"];
};
decoder.Decoder.prototype.defaults = {
handlers: {
"_": function (v, d) {
return types.nullValue();
},
"?": function (v, d) {
return types.boolValue(v);
},
"b": function (v, d) {
return types.binary(v, d);
},
"i": function (v, d) {
return types.intValue(v);
},
"n": function (v, d) {
return types.bigInteger(v);
},
"d": function (v, d) {
return types.floatValue(v);
},
"f": function (v, d) {
return types.bigDecimalValue(v);
},
"c": function (v, d) {
return types.charValue(v);
},
":": function (v, d) {
return types.keyword(v);
},
"$": function (v, d) {
return types.symbol(v);
},
"r": function (v, d) {
return types.uri(v);
},
"z": function (v, d) {
return types.specialDouble(v);
},
// tagged
"'": function (v, d) {
return v;
},
"m": function (v, d) {
return types.date(v);
},
"t": function (v, d) {
return types.verboseDate(v);
},
"u": function (v, d) {
return types.uuid(v);
},
"set": function (v, d) {
return types.set(v);
},
"list": function (v, d) {
return types.list(v);
},
"link": function (v, d) {
return types.link(v);
},
"cmap": function (v, d) {
return types.map(v, false);
}
},
defaultHandler: function (c, val) {
return types.taggedValue(c, val);
},
preferStrings: true,
preferBuffers: true
};
/**
* @param {*} node
* @param {*} cache
* @param {boolean=} asMapKey
* @param {boolean=} tagValue
* @returns {*}
*/
decoder.Decoder.prototype.decode = function (node, cache, asMapKey, tagValue) {
if (node == null) return null;
var t = typeof node;
switch (t) {
case "string":
return this.decodeString(node, cache, asMapKey, tagValue);
break;
case "object":
if (util.isArray(node)) {
if (node[0] === "^ ") {
return this.decodeArrayHash(node, cache, asMapKey, tagValue);
} else {
return this.decodeArray(node, cache, asMapKey, tagValue);
}
} else {
return this.decodeHash(node, cache, asMapKey, tagValue);
}
break;
}
return node;
};
decoder.Decoder.prototype["decode"] = decoder.Decoder.prototype.decode;
decoder.Decoder.prototype.decodeString = function (string, cache, asMapKey, tagValue) {
if (caching.isCacheable(string, asMapKey)) {
var val = this.parseString(string, cache, false);
if (cache) {
cache.write(val, asMapKey);
}
return val;
} else if (caching.isCacheCode(string)) {
return cache.read(string, asMapKey);
} else {
return this.parseString(string, cache, asMapKey);
}
};
decoder.Decoder.prototype.decodeHash = function (hash, cache, asMapKey, tagValue) {
var ks = util.objectKeys(hash),
key = ks[0],
tag = ks.length == 1 ? this.decode(key, cache, false, false) : null;
if (decoder.isTag(tag)) {
var val = hash[key],
handler = this.handlers[tag.str];
if (handler != null) {
return handler(this.decode(val, cache, false, true), this);
} else {
return types.taggedValue(tag.str, this.decode(val, cache, false, false));
}
} else if (this.mapBuilder) {
if ((ks.length < (types.SMALL_ARRAY_MAP_THRESHOLD * 2)) && this.mapBuilder.fromArray) {
var nodep = [];
for (var i = 0; i < ks.length; i++) {
var strKey = ks[i];
nodep.push(this.decode(strKey, cache, true, false));
nodep.push(this.decode(hash[strKey], cache, false, false));
}
return this.mapBuilder.fromArray(nodep, hash);
} else {
var ret = this.mapBuilder.init(hash);
for (var i = 0; i < ks.length; i++) {
var strKey = ks[i];
ret = this.mapBuilder.add(ret,
this.decode(strKey, cache, true, false),
this.decode(hash[strKey], cache, false, false),
hash);
}
return this.mapBuilder.finalize(ret, hash);
}
} else {
var nodep = [];
for (var i = 0; i < ks.length; i++) {
var strKey = ks[i];
nodep.push(this.decode(strKey, cache, true, false));
nodep.push(this.decode(hash[strKey], cache, false, false));
}
return types.map(nodep, false);
}
};
decoder.Decoder.prototype.decodeArrayHash = function (node, cache, asMapKey, tagValue) {
if (this.mapBuilder) {
if ((node.length < ((types.SMALL_ARRAY_MAP_THRESHOLD * 2) + 1)) && this.mapBuilder.fromArray) {
var nodep = [];
for (var i = 1; i < node.length; i += 2) {
nodep.push(this.decode(node[i], cache, true, false));
nodep.push(this.decode(node[i + 1], cache, false, false));
}
return this.mapBuilder.fromArray(nodep, node);
} else {
var ret = this.mapBuilder.init(node);
for (var i = 1; i < node.length; i += 2) {
ret = this.mapBuilder.add(ret,
this.decode(node[i], cache, true, false),
this.decode(node[i + 1], cache, false, false),
node)
}
return this.mapBuilder.finalize(ret, node);
}
} else {
var nodep = [];
// collect keys
for (var i = 1; i < node.length; i += 2) {
nodep.push(this.decode(node[i], cache, true, false));
nodep.push(this.decode(node[i + 1], cache, false, false));
}
return types.map(nodep, false);
}
};
decoder.Decoder.prototype.decodeArray = function (node, cache, asMapKey, tagValue) {
if (tagValue) {
var ret = [];
for (var i = 0; i < node.length; i++) {
ret.push(this.decode(node[i], cache, asMapKey, false));
}
return ret;
} else {
var cacheIdx = cache && cache.idx;
// tagged value as 2-array case
if ((node.length === 2) &&
(typeof node[0] === "string")) {
var tag = this.decode(node[0], cache, false, false);
if (decoder.isTag(tag)) {
var val = node[1],
handler = this.handlers[tag.str];
if (handler != null) {
var ret = handler(this.decode(val, cache, asMapKey, true), this);
return ret;
} else {
return types.taggedValue(tag.str, this.decode(val, cache, asMapKey, false))
}
}
}
// rewind cache
if (cache && (cacheIdx != cache.idx)) {
cache.idx = cacheIdx;
}
if (this.arrayBuilder) {
// NOTE: hard coded for ClojureScript for now - David
if (node.length <= 32 && this.arrayBuilder.fromArray) {
var arr = [];
for (var i = 0; i < node.length; i++) {
arr.push(this.decode(node[i], cache, asMapKey, false));
}
return this.arrayBuilder.fromArray(arr, node);
} else {
var ret = this.arrayBuilder.init(node);
for (var i = 0; i < node.length; i++) {
ret = this.arrayBuilder.add(ret, this.decode(node[i], cache, asMapKey, false), node);
}
return this.arrayBuilder.finalize(ret, node);
}
} else {
var ret = [];
for (var i = 0; i < node.length; i++) {
ret.push(this.decode(node[i], cache, asMapKey, false));
}
return ret;
}
}
};
decoder.Decoder.prototype.parseString = function (string, cache, asMapKey) {
if (string.charAt(0) === d.ESC) {
var c = string.charAt(1);
if (c === d.ESC || c === d.SUB || c === d.RES) {
return string.substring(1);
} else if (c === d.TAG) {
return decoder.tag(string.substring(2));
} else {
var handler = this.handlers[c];
if (handler == null) {
return this.defaultHandler(c, string.substring(2));
} else {
return handler(string.substring(2), this);
}
}
} else {
return string;
}
};
decoder.decoder = function (options) {
return new decoder.Decoder(options);
};
});
© 2015 - 2025 Weber Informatics LLC | Privacy Policy