_id
stringlengths 2
6
| title
stringlengths 0
58
| partition
stringclasses 3
values | text
stringlengths 52
373k
| language
stringclasses 1
value | meta_information
dict |
---|---|---|---|---|---|
q5300
|
train
|
function(inputs, callback) {
// Remove any empty inputs
var filteredInputs = RunUtil.filterEmptyInputs(inputs || []);
runner.run(method.slug, script, {
input: filteredInputs
}, function(err, result) {
if(err) {
callback(err);
} else {
callback(null, result);
}
});
}
|
javascript
|
{
"resource": ""
}
|
|
q5301
|
train
|
function(flags, checkFlags, value) {
[].concat(checkFlags || []).forEach((function(flag, i) {
if (i == value) {
this.ensureFlag(flags, flag);
} else {
this.removeFlag(flags, flag);
}
}.bind(this)));
}
|
javascript
|
{
"resource": ""
}
|
|
q5302
|
Client
|
train
|
function Client(appId, options) {
this.appId = appId;
this.stubbed = false;
this.userAgent = defaultUserAgent;
this._validator = new Validator();
// NOTE: We need to add a listener to the "error" event so the users aren't
// forced to set up a listener themselves. If no listener for "error"
// exists, emitting the event results in an uncaught error.
this.on("error", function() { });
if (options) {
for (var property in options) {
if (!options.hasOwnProperty(property))
continue;
this[property] = options[property];
}
}
}
|
javascript
|
{
"resource": ""
}
|
q5303
|
addToContainer
|
train
|
function addToContainer(container, key, val) {
if (container instanceof Array) {
container.push(val);
} else if (container instanceof Object) {
container[key] = val;
}
}
|
javascript
|
{
"resource": ""
}
|
q5304
|
train
|
function(dir) {
var methods = [];
var findConfigFiles = function(dir) {
fs.readdirSync(dir).forEach(function(file) {
file = path.join(dir, file);
var stat = fs.statSync(file);
if(stat && stat.isDirectory()) {
findConfigFiles(file);
} else if(/config.js$/.test(file)) {
methods.push(file);
}
});
};
findConfigFiles(dir);
return methods;
}
|
javascript
|
{
"resource": ""
}
|
|
q5305
|
runCmd
|
train
|
function runCmd(cmd) {
return new Promise((resolve, reject) => {
exec(cmd, {}, function(err, stdout) {
if(err) {
console.error(stdout);
return reject(err);
}
return resolve(stdout);
});
});
}
|
javascript
|
{
"resource": ""
}
|
q5306
|
train
|
function(value) {
var d = FxoUtils.parseDateTimeField(value);
return d.valid ? d.parsed.getTime() : NaN;
}
|
javascript
|
{
"resource": ""
}
|
|
q5307
|
train
|
function(value, options) {
var format = options.dateOnly ?
'{yyyy}-{MM}-{dd}' :
'{yyyy}-{MM}-{dd} {hh}:{mm}:{ss}';
var d = FxoUtils.parseDateTimeField(value);
return d.parsed.format(format);
}
|
javascript
|
{
"resource": ""
}
|
|
q5308
|
source
|
train
|
function source(value, indent, limit, offset, visited) {
var result;
var names;
var nestingIndex;
var isCompact = !isUndefined(limit);
indent = indent || " ";
offset = (offset || "");
result = "";
visited = visited || [];
if (isUndefined(value)) {
result += "undefined";
}
else if (isNull(value)) {
result += "null";
}
else if (isString(value)) {
result += "\"" + value + "\"";
}
else if (isFunction(value)) {
value = String(value).split("\n");
if (isCompact && value.length > 2) {
value = value.splice(0, 2);
value.push("...}");
}
result += value.join("\n" + offset);
}
else if (isArray(value)) {
if ((nestingIndex = (visited.indexOf(value) + 1))) {
result = "#" + nestingIndex + "#";
}
else {
visited.push(value);
if (isCompact)
value = value.slice(0, limit);
result += "[\n";
result += value.map(function(value) {
return offset + indent + source(value, indent, limit, offset + indent,
visited);
}).join(",\n");
result += isCompact && value.length > limit ?
",\n" + offset + "...]" : "\n" + offset + "]";
}
}
else if (isObject(value)) {
if ((nestingIndex = (visited.indexOf(value) + 1))) {
result = "#" + nestingIndex + "#"
}
else {
visited.push(value)
names = Object.keys(value);
result += "{ // " + value + "\n";
result += (isCompact ? names.slice(0, limit) : names).map(function(name) {
var _limit = isCompact ? limit - 1 : limit;
var descriptor = Object.getOwnPropertyDescriptor(value, name);
var result = offset + indent + "// ";
var accessor;
if (0 <= name.indexOf(" "))
name = "\"" + name + "\"";
if (descriptor.writable)
result += "writable ";
if (descriptor.configurable)
result += "configurable ";
if (descriptor.enumerable)
result += "enumerable ";
result += "\n";
if ("value" in descriptor) {
result += offset + indent + name + ": ";
result += source(descriptor.value, indent, _limit, indent + offset,
visited);
}
else {
if (descriptor.get) {
result += offset + indent + "get " + name + " ";
accessor = source(descriptor.get, indent, _limit, indent + offset,
visited);
result += accessor.substr(accessor.indexOf("{"));
}
if (descriptor.set) {
if (descriptor.get) result += ",\n";
result += offset + indent + "set " + name + " ";
accessor = source(descriptor.set, indent, _limit, indent + offset,
visited);
result += accessor.substr(accessor.indexOf("{"));
}
}
return result;
}).join(",\n");
if (isCompact) {
if (names.length > limit && limit > 0) {
result += ",\n" + offset + indent + "//...";
}
}
else {
if (names.length)
result += ",";
result += "\n" + offset + indent + "\"__proto__\": ";
result += source(Object.getPrototypeOf(value), indent, 0,
offset + indent);
}
result += "\n" + offset + "}";
}
}
else {
result += String(value);
}
return result;
}
|
javascript
|
{
"resource": ""
}
|
q5309
|
ApiError
|
train
|
function ApiError(response, client) {
this.name = "heap.ApiError";
this.response = response;
this.client = client;
this.message = this.toString();
Error.captureStackTrace(this, ApiError);
}
|
javascript
|
{
"resource": ""
}
|
q5310
|
init
|
train
|
function init(options, callback, proxies, logLevel) {
if (! callback) {
log.error("The end callback is not defined");
}
// Default options
globalOptions = createDefaultOptions();
// Merge default options values & overridden values provided by the arg options
if (options) {
_.extend(globalOptions, options);
}
// if using rateLimits we want to use only one connection with delay between requests
if (globalOptions.rateLimits !== 0) {
globalOptions.maxConnections = 1;
}
// create the crawl store
store.createStore(globalOptions.storeModuleName, globalOptions.storeParams ? globalOptions.storeParams : null);
// If the options object contains an new implementation of the updateDepth method
if (globalOptions.updateDepth) {
updateDepthFn = globalOptions.updateDepth;
}
// Init the crawl queue
endCallback = callback;
requestQueue.init(globalOptions, crawl, recrawl, endCallback, proxies);
if (logLevel) {
console.log("Change Log level into :" + logLevel);
log.level(logLevel);
}
else {
log.level("info"); // By default debug level is not activated
}
}
|
javascript
|
{
"resource": ""
}
|
q5311
|
queue
|
train
|
function queue(options) {
if (! endCallback) {
console.log("The end callback is not defined, impossible to run correctly");
return;
}
// Error if no options
if (! options){
crawl({errorCode : "NO_OPTIONS"}, {method:"GET", url : "unknown", proxy : "", error : true},
function(error){
if (requestQueue.idle()) {
endCallback();
}
});
return;
}
// if Array => recall this method for each element
if (_.isArray(options)) {
options.forEach(function(opt){
queue(opt);
});
return;
}
// if String, we expect to receive an url
if (_.isString(options)) {
addInQueue(addDefaultOptions({url:options}, globalOptions));
}
// Last possibility, this is a json
else {
if (! _.has(options, "url") && ! _.has(options, "url")) {
crawl({errorCode : "NO_URL_OPTION"}, {method:"GET", url : "unknown", proxy : "", error : true},
function(error){
if (requestQueue.idle()) {
endCallback();
}
});
}
else {
addInQueue(addDefaultOptions(options, globalOptions));
}
}
}
|
javascript
|
{
"resource": ""
}
|
q5312
|
addDefaultOptions
|
train
|
function addDefaultOptions(options, defaultOptions) {
_.defaults(options, defaultOptions);
options.currentRetries = 0;
return options;
}
|
javascript
|
{
"resource": ""
}
|
q5313
|
buildNewOptions
|
train
|
function buildNewOptions (options, newUrl) {
// Old method
/*
var o = createDefaultOptions(newUrl);
// Copy only options attributes that are in the options used for the previous request
// Could be more simple ? ;-)
o = _.extend(o, _.pick(options, _.without(_.keys(o), "url")));
*/
var o = _.clone(options);
o.url = newUrl;
o.depthLimit = options.depthLimit;
o.currentRetries = 0;
if (options.canCrawl) {
o.canCrawl = options.canCrawl;
}
return o;
}
|
javascript
|
{
"resource": ""
}
|
q5314
|
createDefaultOptions
|
train
|
function createDefaultOptions(url) {
var options = {
referer : DEFAULT_REFERER,
skipDuplicates : DEFAULT_SKIP_DUPLICATES,
maxConnections : DEFAULT_NUMBER_OF_CONNECTIONS,
rateLimits : DEFAULT_RATE_LIMITS,
externalDomains : DEFAULT_CRAWL_EXTERNAL_DOMAINS,
externalHosts : DEFAULT_CRAWL_EXTERNAL_HOSTS,
firstExternalLinkOnly : DEFAULT_FIRST_EXTERNAL_LINK_ONLY,
scripts : DEFAULT_CRAWL_SCRIPTS,
links : DEFAULT_CRAWL_LINKS,
linkTypes : DEFAULT_LINKS_TYPES,
images : DEFAULT_CRAWL_IMAGES,
protocols : DEFAULT_PROTOCOLS_TO_CRAWL,
timeout : DEFAULT_TIME_OUT,
retries : DEFAULT_RETRIES,
retryTimeout : DEFAULT_RETRY_TIMEOUT,
depthLimit : DEFAULT_DEPTH_LIMIT,
followRedirect : DEFAULT_FOLLOW_301,
userAgent : DEFAULT_USER_AGENT,
domainBlackList : domainBlackList,
suffixBlackList : suffixBlackList,
retry400 : DEFAULT_RETRY_400,
isExternal : false,
storeModuleName : DEFAULT_STORE_MODULE,
queueModuleName : DEFAULT_QUEUE_MODULE,
jar : DEFAULT_JAR
};
if (url) {
options.url = url;
}
return options;
}
|
javascript
|
{
"resource": ""
}
|
q5315
|
analyzeHTML
|
train
|
function analyzeHTML(result, $, callback) {
// if $ is note defined, this is not a HTML page with an http status 200
if (! $) {
return callback();
}
log.debug({"url" : result.url, "step" : "analyzeHTML", "message" : "Start check HTML code"});
async.parallel([
async.apply(crawlHrefs, result, $),
async.apply(crawlLinks, result, $),
async.apply(crawlScripts, result, $),
async.apply(crawlImages, result, $),
], callback);
}
|
javascript
|
{
"resource": ""
}
|
q5316
|
crawlHrefs
|
train
|
function crawlHrefs(result, $, endCallback) {
log.debug({"url" : result.url, "step" : "analyzeHTML", "message" : "CrawlHrefs"});
async.each($('a'), function(a, callback) {
crawlHref($, result, a, callback);
}, endCallback);
}
|
javascript
|
{
"resource": ""
}
|
q5317
|
crawlHref
|
train
|
function crawlHref($,result, a, callback) {
var link = $(a).attr('href');
var parentUrl = result.url;
if (link) {
var anchor = $(a).text() ? $(a).text() : "";
var noFollow = $(a).attr("rel");
var isDoFollow = ! (noFollow && noFollow === "nofollow");
var linkUri = URI.linkToURI(parentUrl, link);
pm.crawlLink(parentUrl, linkUri, anchor, isDoFollow, function(){
addLinkToQueue(result, parentUrl, linkUri, anchor, isDoFollow, callback);
});
}
else {
callback();
}
}
|
javascript
|
{
"resource": ""
}
|
q5318
|
crawLink
|
train
|
function crawLink($,result,linkTag, callback) {
var link = $(linkTag).attr('href');
var parentUrl = result.url;
if (link) {
var rel = $(linkTag).attr('rel');
if (result.linkTypes.indexOf(rel) > 0) {
var linkUri = URI.linkToURI(parentUrl, link);
pm.crawlLink(parentUrl, linkUri, null, null, function(){
addLinkToQueue(result, parentUrl, linkUri, null, null, callback);
});
}
else {
callback();
}
}
else {
callback();
}
}
|
javascript
|
{
"resource": ""
}
|
q5319
|
crawlScripts
|
train
|
function crawlScripts(result, $, endCallback) {
if (! result.scripts) {
return endCallback();
}
log.debug({"url" : result.url, "step" : "analyzeHTML", "message" : "CrawlScripts"});
async.each($('script'), function(script, callback) {
crawlScript($, result, script, callback);
}, endCallback);
}
|
javascript
|
{
"resource": ""
}
|
q5320
|
crawlScript
|
train
|
function crawlScript($,result, script, callback) {
var link = $(script).attr('src');
var parentUrl = result.url;
if (link) {
var linkUri = URI.linkToURI(parentUrl, link);
pm.crawlLink(parentUrl, linkUri, null, null, function(){
addLinkToQueue(result, parentUrl, linkUri, null, null, callback);
});
}
else {
callback();
}
}
|
javascript
|
{
"resource": ""
}
|
q5321
|
crawlImages
|
train
|
function crawlImages(result, $, endCallback) {
if (! result.images) {
return endCallback();
}
log.debug({"url" : result.url, "step" : "analyzeHTML", "message" : "CrawlImages"});
async.each($('img'), function(img, callback) {
crawlImage($, result, img, callback);
}, endCallback);
}
|
javascript
|
{
"resource": ""
}
|
q5322
|
crawlImage
|
train
|
function crawlImage ($,result, img, callback) {
var parentUrl = result.url;
var link = $(img).attr('src');
var alt = $(img).attr('alt');
if (link) {
var linkUri = URI.linkToURI(parentUrl, link);
pm.crawlImage(parentUrl, linkUri, alt, function(){
addLinkToQueue(result, parentUrl, linkUri, null, null, callback);
});
}
else {
callback();
}
}
|
javascript
|
{
"resource": ""
}
|
q5323
|
updateDepth
|
train
|
function updateDepth(parentUrl, linkUri, callback) {
var depths = {parentUrl : parentUrl, linkUri : linkUri, parentDepth : 0, linkDepth : 0};
var execFns = async.seq(getDepths , calcultateDepths , saveDepths);
execFns(depths, function (error, result) {
if (error) {
return callback(error);
}
callback(error, result.linkDepth);
});
}
|
javascript
|
{
"resource": ""
}
|
q5324
|
getDepths
|
train
|
function getDepths(depths, callback) {
async.parallel([
async.apply(store.getStore().getDepth.bind(store.getStore()), depths.parentUrl),
async.apply(store.getStore().getDepth.bind(store.getStore()), depths.linkUri)
],
function(error, results){
if (error) {
return callback(error);
}
depths.parentDepth = results[0];
depths.linkDepth = results[1];
callback(null, depths);
});
}
|
javascript
|
{
"resource": ""
}
|
q5325
|
calcultateDepths
|
train
|
function calcultateDepths(depths, callback) {
if (depths.parentDepth) {
// if a depth of the links doesn't exist : assign the parehtDepth +1
// if not, this link has been already found in the past => don't update its depth
if (! depths.linkDepth) {
depths.linkDepth = depths.parentDepth + 1;
}
}
else {
depths.parentDepth = 0;
depths.linkDepth = 1;
}
callback(null, depths);
}
|
javascript
|
{
"resource": ""
}
|
q5326
|
saveDepths
|
train
|
function saveDepths(depths, callback) {
async.parallel([
async.apply(store.getStore().setDepth.bind(store.getStore()), depths.parentUrl, depths.parentDepth ),
async.apply(store.getStore().setDepth.bind(store.getStore()), depths.linkUri, depths.linkDepth )
],
function(error){
callback(error, depths);
});
}
|
javascript
|
{
"resource": ""
}
|
q5327
|
extend
|
train
|
function extend(d, element) {
var map = Object.keys(element.prototype).reduce(function (descriptors, key) {
descriptors[key] = Object.getOwnPropertyDescriptor(element.prototype, key);
return descriptors;
}, {});
Object.defineProperties(d, map);
}
|
javascript
|
{
"resource": ""
}
|
q5328
|
init
|
train
|
function init (options, crawlCallback, recrawlCallback, endCallback, proxies) {
requestQueue = require(options.queueModuleName);
requestQueue.init(options, onUrlToCrawl, endCallback);
onCrawl = crawlCallback;
onRecrawl = recrawlCallback;
proxyList = proxies;
}
|
javascript
|
{
"resource": ""
}
|
q5329
|
queue
|
train
|
function queue(options, callback) {
// if skipDuplicates, don't crawl twice the same url
if (options.skipDuplicates) {
store.getStore().checkInCrawlHistory(options.url, function(error, isInCrawlHistory) {
if (isInCrawlHistory) {
log.debug({"url" : options.url, "step" : "queue-resquester.queue", "message" : "Don't crawl this url - Option skipDuplicates=true & the url has already been crawled" });
callback();
}
else {
//numOfUrl++
//console.log("Queue length : " + requestQueue.length() + " - Running : " + requestQueue.running() + " - Total Add :" + numOfUrl + " - Total End : " + endUrl + " url : " + options.url );
log.debug({"url" : options.url, "step" : "queue-resquester.queue", "message" : "Add in the request queue"});
requestQueue.push(options);
callback();
}
});
}
else {
//numOfUrl++
//console.log("Queue length : " + requestQueue.length() + " - Running : " + requestQueue.running() + " - Total Add :" + numOfUrl + " - Total End : " + endUrl + " url : " + options.url );
log.info({"url" : options.url, "step" : "queue-resquester.queue", "message" : "Add in the request queue"});
requestQueue.push(options);
callback();
}
}
|
javascript
|
{
"resource": ""
}
|
q5330
|
execHttp
|
train
|
function execHttp(options, callback) {
if (proxyList) {
options.proxy = proxyList.getProxy().getUrl();
}
log.debug({"url" : options.url, "step" : "queue-requester.execHttp", "message" : "Execute the request"});
request.get(options, function(error, result) {
log.debug({"url" : options.url, "step" : "queue-requester.execHttp", "message" : "Execute the request done"});
// TODO : review this solution/try to understand the origin of this problem
// some sites provide inconsistent response for some urls (status 40* instead of 200).
// In such case, it should be nice to retry (if the option retry400 == true)
if (result.statusCode && result.statusCode >= 400 && result.statusCode <= 499 && result.retry400) {
error = new Error("40* Error");
error.code = result.statusCode;
}
if (error) {
onRequestError(error, result, function(error){
process.nextTick(function() {callback(error);});
});
}
else {
onCrawl(null, result, function(error){
process.nextTick(function() {callback(error);});
});
}
});
}
|
javascript
|
{
"resource": ""
}
|
q5331
|
retrySameUrl
|
train
|
function retrySameUrl(error, options, callback) {
if (options.currentRetries <= options.retries) {
log.warn({"url" : options.url, "step" : "queue-requester.recrawlUrl", "message" : "Recrawl - retries : " + options.currentRetries});
options.crawlWithDelay = true;
//TODO : async this code
// Reinject the same request in the queue
// 1. Remove it from the crawl history in order to support the option skipDuplicates = true
store.getStore().removeFromHistory(options.url);
// 2. Add it again in the queue with the same options
queue(options, callback);
}
else {
onCrawl(error, options, function(error){
process.nextTick(function() {callback(error);});
});
}
}
|
javascript
|
{
"resource": ""
}
|
q5332
|
Tokenizer
|
train
|
function Tokenizer(str) {
this.str = (str || '').toString();
this.operatorCurrent = '';
this.operatorExpecting = '';
this.node = null;
this.escaped = false;
this.list = [];
}
|
javascript
|
{
"resource": ""
}
|
q5333
|
Plugin
|
train
|
function Plugin() {
this.name = "Audit-Plugin";
this.resources = new Map();
this.duplicateContents = new Map();
this.inLinks = new Map();
this.outLinks = new Map();
this.externalLinks = new Map();
this.unparsedLinks = new Set();
this.images = new Map();
this.errors = new Set();
this.redirects = new Map();
}
|
javascript
|
{
"resource": ""
}
|
q5334
|
train
|
function(map, key, value) {
var list = [];
if (map.has(key)) {
list = map.get(key);
if (!list) {
list = [];
}
}
list.push(value);
map.set(key, list);
}
|
javascript
|
{
"resource": ""
}
|
|
q5335
|
AssertionError
|
train
|
function AssertionError(options) {
var assertionError = Object.create(AssertionError.prototype);
if (utils.isString(options))
options = { message: options };
if ("actual" in options)
assertionError.actual = options.actual;
if ("expected" in options)
assertionError.expected = options.expected;
if ("operator" in options)
assertionError.operator = options.operator;
assertionError.message = options.message;
assertionError.stack = new Error().stack;
return assertionError;
}
|
javascript
|
{
"resource": ""
}
|
q5336
|
equal
|
train
|
function equal(actual, expected, message) {
if (actual == expected) {
this.pass(message);
}
else {
this.fail({
actual: actual,
expected: expected,
message: message,
operator: "=="
});
}
}
|
javascript
|
{
"resource": ""
}
|
q5337
|
notEqual
|
train
|
function notEqual(actual, expected, message) {
if (actual != expected) {
this.pass(message);
}
else {
this.fail({
actual: actual,
expected: expected,
message: message,
operator: "!=",
});
}
}
|
javascript
|
{
"resource": ""
}
|
q5338
|
notStrictEqual
|
train
|
function notStrictEqual(actual, expected, message) {
if (actual !== expected) {
this.pass(message);
}
else {
this.fail({
actual: actual,
expected: expected,
message: message,
operator: "!=="
})
}
}
|
javascript
|
{
"resource": ""
}
|
q5339
|
train
|
function(obj) {
var cloned = {};
for(var key in obj) {
if(obj.hasOwnProperty(key)) {
cloned[key] = obj[key];
}
}
return cloned;
}
|
javascript
|
{
"resource": ""
}
|
|
q5340
|
train
|
function(prevHandler, connection, parsed, data, callback) {
if (hasCondstoreOption(parsed.attributes && parsed.attributes[1], parsed.attributes, 1)) {
connection.sessionCondstore = true;
} else if ('sessionCondstore' in connection) {
connection.sessionCondstore = false;
}
prevHandler(connection, parsed, data, callback);
}
|
javascript
|
{
"resource": ""
}
|
|
q5341
|
train
|
function () {
var map, bounds, coords;
if (this.isDestroying || this.isDestroyed) {
return;
}
map = this.get('googleObject');
if (this._state !== 'inDOM' || !map) {
this._scheduleAutoFitBounds(coords);
return;
}
coords = this.get('fitBoundsArray');
if (!coords) {
return;
}
if (Ember.isArray(coords)) {
// it's an array of lat,lng
coords = coords.slice();
if (get$(coords, 'length')) {
bounds = new google.maps.LatLngBounds(helpers._latLngToGoogle(coords.shift()));
forEach(coords, function (point) {
bounds.extend(helpers._latLngToGoogle(point));
});
}
else {
return;
}
}
else {
// it's a bound object
bounds = helpers._boundsToGoogle(coords);
}
if (bounds) {
// finally make our map to fit
map.fitBounds(bounds);
}
}
|
javascript
|
{
"resource": ""
}
|
|
q5342
|
head
|
train
|
function head(url, uploadOptions, redirectCount, callback) {
var options = getRequestOptions('HEAD', url, uploadOptions.downloadHeaders, uploadOptions.downloadAgent);
var downloadProtocol = getProtocol(url);
var req = downloadProtocol.request(options, function(res) {
try {
if ((res.statusCode == 301) || (res.statusCode == 302)) {
if (redirectCount >= uploadOptions.maxRedirects) {
return callback('Redirect count reached. Aborting upload.');
}
var location = res.headers.location;
if (location) {
redirectCount++;
var redirectUrl = parseUri(location);
return head(redirectUrl, uploadOptions, redirectCount, callback);
}
}
if ((res.statusCode < 200) || (res.statusCode >= 300)) {
return callback('Invalid response from remote file server. statusCode: ' + res.statusCode);
}
var contentLength = parseInt(res.headers['content-length'], 10);
if (isNaN(contentLength)) { //this shouldn't happen, but it does
return callback('Remote web server returned an invalid content length');
}
if (!validateFileSize(uploadOptions.maxFileSize, contentLength)) {
return callback('File is too large. maxFileSize: ' + uploadOptions.maxFileSize + ', content-length: ' + contentLength);
}
//can we bail out early?
if (uploadOptions.downloadFileName) {
return callback(null, url, contentLength, uploadOptions.downloadFileName);
}
//no download specified, attempt to parse one out
var file, ext, mimeExt;
var contentType = res.headers['content-type'].split(';')[0];
//attempt to get the filename from the url
file = sanitizeFileName(path.basename(url.pathname));
if (file) {
ext = path.extname(file);
file = file.replace(ext, '');
ext = ext.replace('.', '');
if (ext) {
mimeExt = mimetypes.extension(contentType);
if (mimeExt) {
if (ext.toLowerCase() !== '.' + mimeExt.toLowerCase()) {
ext = mimeExt;
}
}
}
}
//default file name if we couldn't parse one
if (!file) { file = 'poster'; }
//default file extension if we cannot find one (unlikely)
if (!ext) {
ext = 'unk';
if (contentType) {
mimeExt = mimetypes.extension(contentType);
if (mimeExt) {
ext = mimeExt;
}
}
}
return callback(null, url, contentLength, file + '.' + ext);
}
catch (e) {
callback(e);
}
});
req.on('error', function(e) {
callback(e);
});
req.end();
}
|
javascript
|
{
"resource": ""
}
|
q5343
|
train
|
function (priorities) {
if (!angular.isArray(priorities)) { return false; }
for (var i = 0; i < priorities.length; i += 1) {
if (service.config.placementPriority.indexOf(priorities[i]) === -1) {
return false;
}
}
return true;
}
|
javascript
|
{
"resource": ""
}
|
|
q5344
|
train
|
function (filter) {
var obj = {}
var val = this.__input
this.each(function (property, key) {
obj[key] = property.flatten ? property.flatten(filter) : property
}, wrapFilter(filter))
if (val !== void 0) {
if (val instanceof Base) {
val = {
reference: val.path
}
}
obj.val = val
}
// refactoring non standard keys
var flattened = flatten(obj)
for (var key in flattened) {
if (key.indexOf('.val') > 0) {
var newKey = key.split('.val')[0]
flattened[newKey] = flattened[key]
delete flattened[key]
}
}
return flattened
}
|
javascript
|
{
"resource": ""
}
|
|
q5345
|
custom
|
train
|
function custom (properties, property, key, event) {
if (property === null) {
properties[key] = null
} else if (property.val) {
property.val = parseProperty(property.val)
var prototype = property.val.prototype
if (prototype && prototype instanceof Base) {
if (property.override) {
properties._overrides = properties._overrides || {}
properties._overrides[key] = property.override
properties[key] = Properties
.createPropertyConstructor(property.val, property.override, true)
properties[key].override = property.override
properties[property.override] = properties[key]
} else {
this[key] = properties[key] = prototype
prototype._parent = this
}
} else {
if (property.override) {
properties[key] = Properties.createPrimitiveProperty(property.override)
} else {
properties[key] = Properties.default
}
properties[key].call(this, property.val, void 0, void 0, key)
}
} else if (key !== '_overrides') {
if (property.type) {
let res = this.getType(property, event, key, void 0)
if (res instanceof Base) {
properties[key] = Properties
.createPropertyConstructor(new res.Constructor(property, false, this, key).Constructor, key)
return
}
}
properties[key] = Properties
.createPropertyConstructor(new this.Child(property, false, this, key).Constructor, key)
}
}
|
javascript
|
{
"resource": ""
}
|
q5346
|
LargeObject
|
train
|
function LargeObject(query, oid, fd)
{
this._query = query;
this.oid = oid;
this._fd = fd;
}
|
javascript
|
{
"resource": ""
}
|
q5347
|
htmlStringify
|
train
|
function htmlStringify(obj, fromRecur) {
var tag = (fromRecur) ? 'span' : 'div';
var nextLevel = (fromRecur || 0) + 1;
// strings
if (typeof obj == 'string') {
return '<' + tag + ' style="color: #0e4889; cursor: default;">"' + obj + '"</' + tag + '>';
}
// booleans, null and undefined
else if (typeof obj == 'boolean' || obj === null || obj === undefined) {
return '<' + tag + '><em style="color: #06624b; cursor: default;">' + obj + '</em></' + tag + '>';
}
// numbers
else if (typeof obj == 'number') {
return '<' + tag + ' style="color: #ca000a; cursor: default;">' + obj + '</' + tag + '>';
}
// dates
else if (Object.prototype.toString.call(obj) == '[object Date]') {
return '<' + tag + ' style="color: #009f7b; cursor: default;">' + obj + '</' + tag + '>';
}
// arrays
else if (Array.isArray(obj)) {
var rtn = '<' + tag + ' style="color: #666; cursor: default;">Array: [';
if (!obj.length) {
return rtn + ']</' + tag + '>';
}
rtn += '</' + tag + '><div style="padding-left: 20px;">';
for (var i = 0; i < obj.length; i++) {
rtn += '<span></span>' + htmlStringify(obj[i], nextLevel); // give the DOM structure has as many elements as an object, for collapse behaviour
if (i < obj.length - 1) {
rtn += ', <br>';
}
}
return rtn + '</div><' + tag + ' style="color: #666">]</' + tag + '>';
}
// objects
else if (obj && typeof obj == 'object') {
var rtn = '',
len = Object.keys(obj).length;
if (fromRecur && !len) {
return '<' + tag + ' style="color: #999; cursor: default;">Object: {}</' + tag + '>';
}
if (fromRecur) {
rtn += '<' + tag + ' style="color: #0b89b6">Object: {</' + tag + '><div class="_stringify_recur _stringify_recur_level_' + fromRecur + '" style="padding-left: 20px;">';
}
for (var key in obj) {
if (typeof obj[key] != 'function') {
rtn += '<div><span style="padding-right: 5px; cursor: default;">' +key + ':</span>' + htmlStringify(obj[key], nextLevel) + '</div>';
}
}
if (fromRecur) {
rtn += '</div><' + tag + ' style="color: #0b89b6; cursor: default;">}</' + tag + '>';
}
return rtn;
}
return '';
}
|
javascript
|
{
"resource": ""
}
|
q5348
|
train
|
function (options) {
events.EventEmitter.call(this);
var defaultOptions = {
tree: {}
};
this.options = extend(defaultOptions, options);
// this.getTreeHTML = this.getTreeHTML;
}
|
javascript
|
{
"resource": ""
}
|
|
q5349
|
train
|
function(params) {
if (!params) {
return {
error: 'params cannot be null.'
};
}
// query is mandatory
if (!params.hasOwnProperty('query')) {
return {
error: 'query param required.'
};
}
if (!validator.isString(params.query)) {
return {
error: 'query must be a string.'
};
}
if (!validator.isValidType(params)) {
return {
error: 'type must be: movie, series, episode.'
};
}
if (params.hasOwnProperty('year') && !validator.isNumber(params.year)) {
return {
error: 'year must be a valid number'
};
}
}
|
javascript
|
{
"resource": ""
}
|
|
q5350
|
train
|
function(params) {
var baseUrl = 'http://www.omdbapi.com/';
var query = '?';
// mandatory
query += 's='.concat(encodeURIComponent(params.query));
if (params.year) {
query += '&y='.concat(params.year);
}
if (params.type) {
query += '&type='.concat(params.type);
}
if (params.apiKey) {
query += '&apikey='.concat(params.apiKey);
}
return baseUrl.concat(query, '&r=json&v=1');
}
|
javascript
|
{
"resource": ""
}
|
|
q5351
|
Notification
|
train
|
function Notification(name, object, info) {
this.name = name;
this.object = object;
this.info = info;
}
|
javascript
|
{
"resource": ""
}
|
q5352
|
getName
|
train
|
function getName(name, width, separator) {
// handle empty separator as no separator
if (typeof separator === 'undefined') {
separator = '';
}
if (name) {
return separator + name;
} else {
return separator + width;
}
}
|
javascript
|
{
"resource": ""
}
|
q5353
|
BlobResource
|
train
|
function BlobResource(uri, context) {
var instance = Resource.call(this, uri, context);
/**
* The resource data.
*
* @type {Blob}
*/
instance.data = '';
return instance;
}
|
javascript
|
{
"resource": ""
}
|
q5354
|
extractAndUpdateResources
|
train
|
function extractAndUpdateResources(data, links, rootResource, resource) {
var resources = [];
var selfHref = ((data._links || {}).self || {}).href;
if (!selfHref) {
throw new Error('Self link href expected but not found');
}
// Extract links
angular.extend(links, data._links);
delete data._links;
// Extract and update embedded resources
Object.keys(data._embedded || {}).forEach(function (rel) {
var embeds = data._embedded[rel];
// Add link to embedded resource if missing
if (!(rel in links)) {
links[rel] = forArray(embeds, function (embedded) {
return {href: embedded._links.self.href};
});
}
// Recurse into embedded resource
forArray(embeds, function (embedded) {
resources = resources.concat(extractAndUpdateResources(embedded, {}, rootResource, null));
});
});
delete data._embedded;
// Update resource
if (!resource) resource = rootResource.$context.get(links.self.href, rootResource.constructor);
Resource.prototype.$update.call(resource, data, links);
resources.push(resource);
return resources;
}
|
javascript
|
{
"resource": ""
}
|
q5355
|
forArray
|
train
|
function forArray(arg, func, context) {
if (angular.isUndefined(arg)) return undefined;
if (Array.isArray(arg)) {
return arg.map(function (elem) {
return func.call(context, elem);
});
} else {
return func.call(context, arg);
}
}
|
javascript
|
{
"resource": ""
}
|
q5356
|
defineProperties
|
train
|
function defineProperties(obj, props) {
props = angular.copy(props);
angular.forEach(props, function (prop) {
if (!('writable' in prop)) prop.writable = true;
});
Object.defineProperties(obj, props);
}
|
javascript
|
{
"resource": ""
}
|
q5357
|
subscribe
|
train
|
function subscribe (obs, path, index, length, type, val, id, fire, origin, event, nocontext) {
if (index === length) {
// TODO added this to subscribe to key => this is probably not the best way to catch this
if (obs.on) {
obs.on('remove', function () {
// null
subscribe(origin, path, 0, length, type, val, id, false, origin, event)
}, id, true, event, nocontext)
obs.on(type, val, id, true, event, nocontext)
}
if (fire) {
// **TODO** SUPER DIRTY
// need to have some godamn arguments
if (event === void 0) {
var trigger = true
event = new Event('data') // wrong
}
if (typeof val === 'function') {
val.call(obs, obs.__input, event)
} else {
// weird gaurd
if (val && val[0]) {
val[0].call(obs, type === 'data' ? obs.__input : void 0, event, val[1])
}
}
if (trigger) {
event.trigger()
}
}
return obs
} else {
let key = path[index]
let property = obs[key]
let result
if (property && property.__input !== null) {
result = subscribe(property, path, index + 1, length, type, val, id, fire, origin, event, nocontext)
} else {
let listenerType = key === 'parent' ? key : 'property'
let listener = function (data, event) {
let property = obs[key]
if (property) {
obs.off(listenerType, id, void 0, true)
subscribe(property, path, index + 1, length, type, val, id, true, origin, event, nocontext)
}
}
obs.on(listenerType, listener, id, true, event, nocontext)
}
// if sub is not fulfilled look in the reference
if (!result) {
let reference = ref(obs)
if (reference) {
subscribe(reference, path, index, length, type, val, id, fire, origin, event, nocontext)
}
}
}
}
|
javascript
|
{
"resource": ""
}
|
q5358
|
train
|
function(pattern, callback) {
glob(pattern, opts, function(err, globbedFiles) {
if (isArray(globbedFiles) && globbedFiles.length && !err) {
callback(null, globbedFiles);
}
else {
console.error('The glob pattern ' + JSON.stringify(pattern) + ' did not match any files!');
callback(null, []);
}
});
}
|
javascript
|
{
"resource": ""
}
|
|
q5359
|
train
|
function() {
var bomBuffer = this.read(bytesPerBom);
if (bomBuffer == null || bomBuffer.length !== bytesPerBom) {
status = 'error';
processor.emit('processing.error', {
file: filePath,
message: 'Skipping file with errors during read: Unable to read past the expected BOM'
});
return callback(null, status);
}
}
|
javascript
|
{
"resource": ""
}
|
|
q5360
|
resolveContext
|
train
|
function resolveContext (emitter, context, storageKey) {
// TODO: clean up - try to use internal context resolve more on no
// use the one from on (resolve)
// figure out why we cant use resolveContextSet since thats what it is
if (context) {
// this is lame stuff! should be in observable in some way...
let base = emitter.parent.parent
let type = emitter.key
let setObj = { on: {} }
setObj.on[type] = {}
// base = base.set(setObj) // .on[type]
emitter = (base.set(setObj) || base)._on[type]
}
if (!emitter.hasOwnProperty(storageKey)) {
emitter.setKey(storageKey, {}, false)
}
return emitter
}
|
javascript
|
{
"resource": ""
}
|
q5361
|
gPrga
|
train
|
function gPrga(key, s) {
var keystream = [];
var k = 0;
var j = 0;
var len = key.length;
for (var i = 0; i < len; ++i) {
k = (k + 1) % 256;
j = (j + s[k]) % 256;
s[j] = [ s[k], s[k] = s[j] ][0];
keystream[i] = s[(s[k] + s[j]) % 256];
}
return keystream;
}
|
javascript
|
{
"resource": ""
}
|
q5362
|
body
|
train
|
function body(inp, ksa, prga, container, length) {
var i = 0, j1 = 0, j2 = 0;
var out = container;
var s1 = ksa.slice();
var s2 = prga.slice();
for (var y = 0; y < length; ++y) {
i = (i + 1) % 256;
j1 = (j1 + s1[i]) % 256;
s1[j1] = [ s1[i], s1[i] = s1[j1] ][0];
out[y] = inp[y] ^ s2[(s1[i] + s1[j1]) % 256];
if (++y < length) {
j2 = (j2 + s2[i]) % 256;
s2[j2] = [ s2[i], s2[i] = s2[j2] ][0];
out[y] = inp[y] ^ s1[(s2[i] + s2[j1]) % 256];
}
}
return out;
}
|
javascript
|
{
"resource": ""
}
|
q5363
|
decodeBlobURL
|
train
|
function decodeBlobURL( bundle, length ) {
var mimeType = bundle.readStringLT(),
blob = new Blob([ bundle.readTypedArray(NUMTYPE.UINT8, length ) ], { type: mimeType });
return DEBUG
? __debugMeta( URL.createObjectURL(blob), 'buffer', { 'mime': mimeType, 'size': length } )
: URL.createObjectURL(blob);
}
|
javascript
|
{
"resource": ""
}
|
q5364
|
decodeBuffer
|
train
|
function decodeBuffer( bundle, len, buf_type ) {
var length=0, ans="";
switch (len) {
case 0: length = bundle.u8[bundle.i8++]; break;
case 1: length = bundle.u16[bundle.i16++]; break;
case 2: length = bundle.u32[bundle.i32++]; break;
case 3: length = bundle.f64[bundle.i64++]; break;
}
// Process buffer according to type
if (buf_type === 0) { // STRING_LATIN
ans = String.fromCharCode.apply(null, bundle.readTypedArray( NUMTYPE.UINT8 , length ) );
return DEBUG
? __debugMeta( ans, 'string.latin', {} )
: ans;
} else if (buf_type === 1) { // STRING_UTF8
ans = String.fromCharCode.apply(null, bundle.readTypedArray( NUMTYPE.UINT16 , length ) );
return DEBUG
? __debugMeta( ans, 'string.utf8', {} )
: ans;
} else if (buf_type === 2) { // IMAGE
var img = document.createElement('img');
img.src = decodeBlobURL( bundle, length );
return img;
} else if (buf_type === 4) { // SCRIPT
var img = document.createElement('script');
img.src = decodeBlobURL( bundle, length );
return img;
} else if (buf_type === 7) { // RESOURCE
return decodeBlobURL( bundle, length );
} else {
throw new Errors.AssertError('Unknown buffer type #'+buf_type+'!');
}
}
|
javascript
|
{
"resource": ""
}
|
q5365
|
decodeObject
|
train
|
function decodeObject( bundle, database, op ) {
if ( !(op & 0x20) || ((op & 0x30) === 0x20) ) { // Predefined objects
var eid = op;
if (op & 0x20) eid = bundle.u8[bundle.i8++] | ((op & 0x0F) << 8);
// Fetch object class
var FACTORY = bundle.profile.decode(eid);
if (FACTORY === undefined) {
throw new Errors.AssertError('Could not found known object entity #'+eid+'!');
}
// Call entity factory
var instance = FACTORY.create();
// Keep on irefs
bundle.iref_table.push( instance );
// Fetch property table
// console.assert(eid != 50);
var prop_table = decodePrimitive( bundle, database );
// Run initializer
FACTORY.init( instance, prop_table, 1, 0 );
// Append debug metadata
DEBUG && __debugMeta( instance, 'object.known', { 'eid': eid } );
return instance;
} else if ((op & 0x3C) === 0x38) { // Primitive object
var poid = (op & 0x03);
switch (poid) {
case 0:
var date = bundle.f64[bundle.i64++];
var tzOffset = bundle.s8[bundle.i8++] * 10;
// Return date
return DEBUG
? __debugMeta( new Date( date ), 'object.date', {} )
: new Date( date );
default:
throw new Errors.AssertError('Unknown primitive object with POID #'+poid+'!');
}
} else if ((op & 0x38) === 0x30) { // Simple object with known signature
// Get values
var eid = ((op & 0x07) << 8) | bundle.u8[bundle.i8++],
values = decodePrimitive( bundle, database ),
factory = bundle.factory_plain[eid];
// Check for invalid objects
if (factory === undefined)
throw new Errors.AssertError('Could not found simple object signature with id #'+eid+'!');
// Create object
return DEBUG
? __debugMeta( factory(values), 'object.plain', { 'eid': eid } )
: factory(values);
} else {
throw new Errors.AssertError('Unexpected object opcode 0x'+op.toString(16)+'!');
}
}
|
javascript
|
{
"resource": ""
}
|
q5366
|
decodePivotArrayFloat
|
train
|
function decodePivotArrayFloat( bundle, database, len, num_type ) {
var ans = new NUMTYPE_CLASS[ NUMTYPE_DELTA_FLOAT.FROM[ num_type ] ]( len ),
// pivot = bundle.readTypedNum( NUMTYPE_DELTA_FLOAT.FROM[ num_type ] ),
scale = bundle.readFloat64(),
values = bundle.readTypedArray( NUMTYPE_DELTA_FLOAT.TO[ num_type ] , len );
// console.log(">> DELTA_FLOAT len=",len,"type=",num_type,"scale=",scale,"pivot=",pivot);
// Decode
for (var i=0; i<len; ++i) {
ans[i] = pivot + (values[i] * scale);
// console.log("<<<", values[i],"->", ans[i]);
}
return DEBUG
? __debugMeta( ans, 'array.delta.float', {} )
: ans;
}
|
javascript
|
{
"resource": ""
}
|
q5367
|
decodeDeltaArrayInt
|
train
|
function decodeDeltaArrayInt( bundle, database, len, num_type ) {
var fromType = NUMTYPE_DELTA_INT.FROM[ num_type ],
ans = new NUMTYPE_CLASS[ fromType ]( len ), v=0;
// readTypedNum(fromType)
switch (fromType) {
case 0: v = bundle.u8[bundle.i8++]; break;
case 1: v = bundle.s8[bundle.i8++]; break;
case 2: v = bundle.u16[bundle.i16++]; break;
case 3: v = bundle.s16[bundle.i16++]; break;
case 4: v = bundle.u32[bundle.i32++]; break;
case 5: v = bundle.s32[bundle.i32++]; break;
case 6: v = bundle.f32[bundle.i32++]; break;
case 7: v = bundle.f64[bundle.i64++]; break;
}
var values = bundle.readTypedArray( NUMTYPE_DELTA_INT.TO[ num_type ] , len - 1 );
// Decode array
ans[0] = v;
for (var i=0, llen=values.length; i<llen; ++i) {
v += values[i];
ans[i+1] = v;
}
// Return
return DEBUG
? __debugMeta( ans, 'array.delta.int', {} )
: ans;
}
|
javascript
|
{
"resource": ""
}
|
q5368
|
decodePlainBulkArray
|
train
|
function decodePlainBulkArray( bundle, database ) {
// Get signature ID
var sid = bundle.u16[bundle.i16++],
properties = bundle.signature_table[sid],
factory = bundle.factory_plain_bulk[sid];
// Check for invalid objects
if (factory === undefined)
throw new Errors.AssertError('Could not found simple object signature with id #'+sid+'!');
// Read property arrays
var values = decodePrimitive( bundle, database );
// Create objects
var len=values.length/properties.length, ans = new Array(len);
for (var i=0; i<len; ++i)
ans[i] = factory(values, i);
return DEBUG
? __debugMeta( ans, 'array.primitive.bulk_plain', { 'sid': sid } )
: ans;
}
|
javascript
|
{
"resource": ""
}
|
q5369
|
decodePrimitive
|
train
|
function decodePrimitive( bundle, database ) {
var op = bundle.u8[bundle.i8++];
if ((op & 0x80) === 0x00) { // Array
return decodeArray(bundle, database,
(op & 0x7F) );
} else if ((op & 0xC0) === 0x80) { // Object
return decodeObject(bundle, database,
(op & 0x3F) );
} else if ((op & 0xE0) === 0xC0) { // Buffer
return decodeBuffer(bundle,
(op & 0x18) >> 3,
(op & 0x07) );
} else if ((op & 0xF0) === 0xE0) { // I-Ref
var id = bundle.u16[bundle.i16++];
id = ((op & 0x0F) << 16) | id;
if (id >= bundle.iref_table.length)
throw new Errors.IRefError('Invalid IREF #'+id+'!');
return DEBUG
? __debugMeta( bundle.iref_table[id], 'object.iref', { 'id': id } )
: bundle.iref_table[id];
} else if ((op & 0xF8) === 0xF0) { // Number
switch (op & 0x07) {
case 0: return bundle.u8[bundle.i8++];
case 1: return bundle.s8[bundle.i8++];
case 2: return bundle.u16[bundle.i16++];
case 3: return bundle.s16[bundle.i16++];
case 4: return bundle.u32[bundle.i32++];
case 5: return bundle.s32[bundle.i32++];
case 6: return bundle.f32[bundle.i32++];
case 7: return bundle.f64[bundle.i64++];
}
} else if ((op & 0xFC) === 0xF8) { // Simple
return PRIM_SIMPLE[ op & 0x03 ];
} else if ((op & 0xFE) === 0xFC) { // Simple_EX
return PRIM_SIMPLE_EX[ op & 0x02 ];
} else if ((op & 0xFF) === 0xFE) { // Import
var name = bundle.readStringLT();
if (database[name] === undefined)
throw new Errors.XRefError('Cannot import undefined external reference '+name+'!');
return DEBUG
? __debugMeta( database[name], 'object.string', { 'key': name } )
: database[name];
} else if ((op & 0xFF) === 0xFF) { // Extended
throw new Errors.AssertError('Encountered RESERVED primitive operator!');
}
}
|
javascript
|
{
"resource": ""
}
|
q5370
|
parseBundle
|
train
|
function parseBundle( bundle, database ) {
while (!bundle.eof()) {
var op = bundle.u8[bundle.i8++];
switch (op) {
case 0xF8: // Export
var export_name = bundle.prefix + bundle.readStringLT();
database[ export_name ] = decodePrimitive( bundle, database );
break;
default:
throw new Errors.AssertError('Unknown control operator 0x'+op.toString(16)+' at @'+bundle.i8+'!');
}
}
}
|
javascript
|
{
"resource": ""
}
|
q5371
|
train
|
function( url, callback ) {
// Node quick, not present on browser builds
if (IS_NODE) {
// Helper function
var readChunk = function ( filename ) {
// Read into buffer
var file = fs.readFileSync(filename),
u8 = new Uint8Array(file);
// Return buffer
return u8.buffer;
}
// Read by chunks
if (url.substr(-5) === ".jbbp") {
// Add by buffer
var base = url.substr(0,url.length-5);
this.addByBuffer( [
readChunk(base + '.jbbp'),
readChunk(base + '_b16.jbbp'),
readChunk(base + '_b32.jbbp'),
readChunk(base + '_b64.jbbp'),
], callback );
} else {
// Add by buffer
this.addByBuffer( readChunk(url), callback );
}
// Don't continue on browser builds
return;
}
// Check for base dir
var prefix = "";
if (this.baseDir)
prefix = this.baseDir + "/";
// Check for sparse bundle
var parts = url.split("?"), suffix = "", reqURL = [];
if (parts.length > 1) suffix = "?"+parts[1];
if (parts[0].substr(parts[0].length - 5).toLowerCase() === ".jbbp") {
var base = prefix + parts[0].substr(0, parts[0].length - 5);
reqURL = [
base + '.jbbp' + suffix,
base + '_b16.jbbp' + suffix,
base + '_b32.jbbp' + suffix,
base + '_b64.jbbp' + suffix
];
} else {
// Assume .jbb if missing (TODO: not a good idea)
var url = parts[0];
if (url.substr(url.length-4) != ".jbb") url += ".jbb";
reqURL = [ prefix + url + suffix ];
}
// Load bundle header and keep a callback
// for the remainging loading operations
var pendingBundle = {
'callback': callback,
'status': PBUND_REQUESTED,
'buffer': undefined,
'url': reqURL
};
// Keep this pending action
this.queuedRequests.push( pendingBundle );
}
|
javascript
|
{
"resource": ""
}
|
|
q5372
|
train
|
function( buffer, callback ) {
// Prepare pending bundle
var pendingBundle = {
'callback': callback,
'status': PBUND_LOADED,
'buffer': buffer,
'url': undefined,
};
// Keep this pending action
this.queuedRequests.push( pendingBundle );
}
|
javascript
|
{
"resource": ""
}
|
|
q5373
|
train
|
function( callback ) {
var self = this;
if (!callback) callback = function(){};
// If there are no queued requests, fire callback as-is
if (this.queuedRequests.length === 0) {
callback( null, this.database );
return;
}
// First make sure that there are no bundles pending loading
var pendingLoading = false;
for (var i=0; i<this.queuedRequests.length; ++i) {
if (this.queuedRequests[i].status === PBUND_REQUESTED) {
pendingLoading = true;
break;
}
}
////////////////////////////////////////////////////////
// Iteration 1 - PBUND_REQUESTED -> PBUND_LOADED
// ----------------------------------------------------
// Download all bundles in pending state.
////////////////////////////////////////////////////////
if (pendingLoading) {
// Prepare the callbacks for when this is finished
var state = { 'counter': 0 }
var continue_callback = (function() {
// When reached 0, continue loading
if (--this.counter === 0)
self.__process( callback );
}).bind(state);
// Place all requests in parallel
var triggeredError = false;
for (var i=0; i<this.queuedRequests.length; ++i) {
var req = this.queuedRequests[i], part = this.progressManager.part();
if (req.status === PBUND_REQUESTED) {
// Download bundle from URL(s)
state.counter++;
req.buffer = downloadArrayBuffers(req.url, part,
(function(req) {
return function( err ) {
// Handle errors
if (err) {
if (triggeredError) return;
var errMsg = "Error downloading bundle: "+err;
if (req.callback) req.callback( errMsg, null);
if (callback) callback(errMsg, null);
triggeredError = true;
return;
}
// Keep buffer and mark as loaded
req.status = PBUND_LOADED;
// Continue
continue_callback();
}
})(req)
);
}
}
// Do not continue, we ar asynchronous
return;
}
////////////////////////////////////////////////////////
// Iteration 2 - PBUND_LOADED -> PBUND_PARSED
// ----------------------------------------------------
// Parse all loaded bundles (synchronous)
////////////////////////////////////////////////////////
for (var i=0; i<this.queuedRequests.length; ++i) {
var req = this.queuedRequests[i];
if (req.status === PBUND_LOADED) {
// try {
// Create bundle from sparse or compact format
var bundle;
if (req.buffer.length === 1) {
bundle = new BinaryBundle( req.buffer[0], self.profile );
} else {
bundle = new BinaryBundle( req.buffer, self.profile );
}
// Parse bundle
parseBundle( bundle, self.database );
// Trigger bundle callback
if (req.callback) req.callback( null, req.bundle );
// } catch (e) {
// // Update bundle status
// req.status = PBUND_ERROR;
// // Fire error callbacks and exit
// var errMsg = "Error parsing bundle: "+e.toString();
// if (req.callback) req.callback( errMsg, null);
// if (callback) callback(errMsg, null);
// return;
// }
}
}
// We are ready
this.queuedRequests = [];
callback( null, this.database );
}
|
javascript
|
{
"resource": ""
}
|
|
q5374
|
compileFile
|
train
|
function compileFile( sourceBundle, bundleFile, config, callback ) {
var fname = sourceBundle + "/bundle.json";
fs.readFile(fname, 'utf8', function (err,data) {
if (err) {
console.error("Unable to load file",fname);
if (callback) callback( err, null );
return;
}
// Update path if missing
if (!config['path'])
config['path'] = path.dirname( sourceBundle );
// Compile
compile( JSON.parse(data), bundleFile, config, callback );
});
}
|
javascript
|
{
"resource": ""
}
|
q5375
|
train
|
function(a,b) {
var tA, tB, i;
for (i=0; i<a.length; ++i) {
tA = typeof a[i]; tB = typeof b[i];
if (tA === tB) {
if ((tA === 'number') || (tA === 'string') || (tA === 'boolean')) {
if (a[i] < b[i]) return -1;
if (a[i] > b[i]) return 1;
if (a[i] !== b[i]) return 1;
/*if (a[i] == b[i]) continue;*/
} else {
if (a[i] === b[i]) continue;
return 1;
}
} else {
return 1;
}
}
return 0;
}
|
javascript
|
{
"resource": ""
}
|
|
q5376
|
getFloatDeltaScale
|
train
|
function getFloatDeltaScale(t, scale) {
if (scale === DELTASCALE.S_1)
return 1.0;
else if (scale === DELTASCALE.S_001)
return 0.01;
else {
var multiplier = 1.0;
if (scale === DELTASCALE.S_R00) multiplier = 100.0;
// Check for INT8 target
if ( ((t >= 0) && (t <= 3)) || (t === 6) ) {
return multiplier * INT8_MAX;
} else {
return multiplier * INT16_MAX;
}
}
}
|
javascript
|
{
"resource": ""
}
|
q5377
|
isEmptyArray
|
train
|
function isEmptyArray(v) {
if ((v instanceof Uint8Array) || (v instanceof Int8Array) ||
(v instanceof Uint16Array) || (v instanceof Int16Array) ||
(v instanceof Uint32Array) || (v instanceof Int32Array) ||
(v instanceof Float32Array) || (v instanceof Float64Array) ||
(v instanceof Array) ) {
return (v.length === 0);
}
return false;
}
|
javascript
|
{
"resource": ""
}
|
q5378
|
isNumericSubclass
|
train
|
function isNumericSubclass( t, t_min, t_max, of_t ) {
if ((t === NUMTYPE.NAN) || (of_t === NUMTYPE.NAN)) return false;
switch (of_t) { // Parent
case NUMTYPE.UINT8:
switch (t) {
case NUMTYPE.UINT8:
return true;
case NUMTYPE.INT8:
return (t_min > 0);
default:
return false;
}
case NUMTYPE.INT8:
switch (t) {
case NUMTYPE.UINT8:
return (t_max < INT8_MAX);
case NUMTYPE.INT8:
return true;
default:
return false;
}
case NUMTYPE.UINT16:
switch (t) {
case NUMTYPE.UINT8:
case NUMTYPE.UINT16:
return true;
case NUMTYPE.INT8:
case NUMTYPE.INT16:
return (t_min > 0);
default:
return false;
}
case NUMTYPE.INT16:
switch (t) {
case NUMTYPE.UINT8:
case NUMTYPE.INT8:
case NUMTYPE.INT16:
return true;
case NUMTYPE.UINT16:
return (t_max < INT16_MAX);
default:
return false;
}
case NUMTYPE.UINT32:
switch (t) {
case NUMTYPE.UINT8:
case NUMTYPE.UINT16:
case NUMTYPE.UINT32:
return true;
case NUMTYPE.INT8:
case NUMTYPE.INT16:
case NUMTYPE.INT32:
return (t_min > 0);
default:
return false;
}
case NUMTYPE.INT32:
switch (t) {
case NUMTYPE.UINT8:
case NUMTYPE.INT8:
case NUMTYPE.UINT16:
case NUMTYPE.INT16:
case NUMTYPE.INT32:
return true;
case NUMTYPE.UINT32:
return (t_max < INT32_MAX);
default:
return false;
}
case NUMTYPE.FLOAT32:
switch (t) {
case NUMTYPE.UINT8:
case NUMTYPE.INT8:
case NUMTYPE.UINT16:
case NUMTYPE.INT16:
case NUMTYPE.FLOAT32:
return true;
case NUMTYPE.UINT32:
case NUMTYPE.INT32:
return (t_min > FLOAT32_NEG) && (t_max < FLOAT32_POS);
default:
return false;
}
case NUMTYPE.FLOAT64:
return true;
}
return false;
}
|
javascript
|
{
"resource": ""
}
|
q5379
|
isFloatMixing
|
train
|
function isFloatMixing( a, b ) {
return (
((a < NUMTYPE.FLOAT32 ) && (b >= NUMTYPE.FLOAT32 )) ||
((a >= NUMTYPE.FLOAT32 ) && (b < NUMTYPE.FLOAT32 ))
);
}
|
javascript
|
{
"resource": ""
}
|
q5380
|
sizeOfType
|
train
|
function sizeOfType(t) {
switch (t) {
case NUMTYPE.UINT8:
case NUMTYPE.INT8:
return 1;
case NUMTYPE.UINT16:
case NUMTYPE.INT16:
return 2;
case NUMTYPE.UINT32:
case NUMTYPE.INT32:
case NUMTYPE.FLOAT32:
return 4;
case NUMTYPE.FLOAT64:
return 8;
}
return 255;
}
|
javascript
|
{
"resource": ""
}
|
q5381
|
getTypedArrayType
|
train
|
function getTypedArrayType( v ) {
if (v instanceof Float32Array) {
return NUMTYPE.FLOAT32;
} else if (v instanceof Float64Array) {
return NUMTYPE.FLOAT64;
} else if (v instanceof Uint8Array) {
return NUMTYPE.UINT8;
} else if (v instanceof Int8Array) {
return NUMTYPE.INT8;
} else if (v instanceof Uint16Array) {
return NUMTYPE.UINT16;
} else if (v instanceof Int16Array) {
return NUMTYPE.INT16;
} else if (v instanceof Uint32Array) {
return NUMTYPE.UINT32;
} else if (v instanceof Int32Array) {
return NUMTYPE.INT32;
} else if (v instanceof Array) {
// Sneaky but fast way to check if array is 100% numeric
// by testing the first, last and middle elemnet
var a=0,b=v.length-1,c=Math.floor((b-a)/2);
if((typeof v[a] === "number") &&
(typeof v[b] === "number") &&
(typeof v[c] === "number")) {
return NUMTYPE.NUMERIC;
} else {
return NUMTYPE.UNKNOWN;
}
} else {
return NUMTYPE.UNKNOWN;
}
}
|
javascript
|
{
"resource": ""
}
|
q5382
|
getNumType
|
train
|
function getNumType( vmin, vmax, is_float ) {
if (typeof vmin !== "number") return NUMTYPE.NAN;
if (typeof vmax !== "number") return NUMTYPE.NAN;
if (isNaN(vmin) || isNaN(vmax)) return NUMTYPE.NAN;
// If float, test only-floats
if (is_float) {
// Try to find smallest value for float32 minimum tests
var smallest;
if (vmin === 0) {
// vmin is 0, which makes vmax positive, so
// test vmax for smallest
smallest = vmax;
} else if (vmax === 0) {
// if vmax is 0, it makes vmin negative, which
// means we should test it's positive version
smallest = -vmax;
} else {
// if vmin is positive, both values are positive
// so get the smallest for small test (vmin)
if (vmin > 0) {
smallest = vmin;
// if vmax is negative, both values are negative
// so get the biggest for small test (vmax)
} else if (vmax < 0) {
smallest = -vmax;
// if vmin is negative and vmax positive, get the
// smallest of their absolute values
} else if ((vmin < 0) && (vmax > 0)) {
smallest = -vmin;
if (vmax < smallest) smallest = vmax;
}
}
// Test if float number fits on 32 or 64 bits
if ((vmin > FLOAT32_NEG) && (vmax < FLOAT32_POS) && (smallest > FLOAT32_SMALL)) {
return NUMTYPE.FLOAT32;
} else {
return NUMTYPE.FLOAT64;
}
}
// If we have a negative value, switch to signed tests
if ((vmax < 0) || (vmin < 0)) {
// Get absolute maximum of bound values
var amax = -vmin;
if (vmax < 0) {
if (-vmax > amax) amax = -vmax;
} else {
if (vmax > amax) amax = vmax;
}
// Test for integer bounds
if (amax < INT8_MAX) {
return NUMTYPE.INT8;
} else if (amax < INT16_MAX) {
return NUMTYPE.INT16;
} else if (amax < INT32_MAX) {
return NUMTYPE.INT32;
} else {
return NUMTYPE.FLOAT64;
}
// Otherwise perform unsigned tests
} else {
// Check for unsigned cases
if (vmax < UINT8_MAX) {
return NUMTYPE.UINT8;
} else if (vmax < UINT16_MAX) {
return NUMTYPE.UINT16;
} else if (vmax < UINT32_MAX) {
return NUMTYPE.UINT32;
} else {
return NUMTYPE.FLOAT64;
}
}
}
|
javascript
|
{
"resource": ""
}
|
q5383
|
getFloatScale
|
train
|
function getFloatScale( values, min, max, error ) {
var mid = (min + max) / 2, range = mid - min,
norm_8 = (range / INT8_MAX),
norm_16 = (range / INT16_MAX),
ok_8 = true, ok_16 = true,
er_8 = 0, er_16 = 0,
v, uv, er;
// For the values given, check if 8-bit or 16-bit
// scaling brings smaller error value
for (var i=0, l=values.length; i<l; ++i) {
// Test 8-bit scaling
if (ok_8) {
v = Math.round((values[i] - mid) / norm_8);
uv = v * norm_8 + mid;
er = (uv-v)/v;
if (er > er_8) er_8 = er;
if (er >= error) {
ok_8 = false;
}
}
// Test 16-bit scaling
if (ok_16) {
v = Math.round((values[i] - mid) / norm_16);
uv = v * norm_16 + mid;
er = (uv-v)/v;
if (er > er_16) er_16 = er;
if (er >= error) {
ok_16 = false;
}
}
if (!ok_8 && !ok_16)
return [ 0, NUMTYPE.UNKNOWN ];
}
// Pick most appropriate normalization factor
if (ok_8 && ok_16) {
if (er_8 < er_16) {
return [ norm_8, NUMTYPE.INT8 ];
} else {
return [ norm_16, NUMTYPE.INT16 ];
}
} else if (ok_8) {
return [ norm_8, NUMTYPE.INT8 ];
} else if (ok_16) {
return [ norm_16, NUMTYPE.INT16 ];
} else {
return [ 0, NUMTYPE.UNKNOWN ];
}
}
|
javascript
|
{
"resource": ""
}
|
q5384
|
getDownscaleType
|
train
|
function getDownscaleType( n_type, analysis ) {
switch (n_type) {
// Not possible to downscale from 1-byte
case NUMTYPE.UINT8:
case NUMTYPE.INT8:
return NUMTYPE.UNKNOWN;
case NUMTYPE.UINT16:
switch (analysis.type) {
// UINT16 -> (U)INT8 = UINT8
case NUMTYPE.INT8: // Unsigned, so always positive
case NUMTYPE.UINT8:
return NUMTYPE.UINT8;
// Anything else is equal to or bigger than 2 bytes
default:
return NUMTYPE.UNKNOWN;
}
case NUMTYPE.INT16:
switch (analysis.type) {
// INT16 -> UINT8 = INT8 (if v < INT8_MAX)
case NUMTYPE.UINT8:
if (analysis.max < INT8_MAX) {
return NUMTYPE.INT8;
} else {
return NUMTYPE.UNKNOWN;
}
// INT16 -> INT8
case NUMTYPE.INT8:
return NUMTYPE.INT8;
// Anything else is equal to or bigger than 2 bytes
default:
return NUMTYPE.UNKNOWN;
}
case NUMTYPE.UINT32:
switch (analysis.type) {
// UINT32 -> (U)INT8 [= UINT8]
case NUMTYPE.INT8:
case NUMTYPE.UINT8:
return NUMTYPE.UINT8;
// UINT32 -> (U)INT16 = UINT16
case NUMTYPE.INT16:
case NUMTYPE.UINT16:
return NUMTYPE.UINT16;
// Anything else is equal to or bigger than 4 bytes
default:
return NUMTYPE.UNKNOWN;
}
case NUMTYPE.INT32:
switch (analysis.type) {
// INT32 -> UINT8 = INT8/INT16 (if v < INT8_MAX)
case NUMTYPE.UINT8:
if (analysis.max < INT8_MAX) {
return NUMTYPE.INT8;
} else {
return NUMTYPE.INT16;
}
// INT32 -> INT8
case NUMTYPE.INT8:
return NUMTYPE.INT8;
// INT32 -> UINT16 = INT16 (if v < INT16_MAX)
case NUMTYPE.UINT16:
if (analysis.max < INT16_MAX) {
return NUMTYPE.INT16;
} else {
return NUMTYPE.UNKNOWN;
}
// INT32 -> INT16
case NUMTYPE.INT16:
return NUMTYPE.INT16;
// Anything else is equal to or bigger than 4 bytes
default:
return NUMTYPE.UNKNOWN;
}
case NUMTYPE.FLOAT32:
switch (analysis.type) {
// FLOAT32 -> Anything 1-2 bytes
case NUMTYPE.UINT8:
return NUMTYPE.UINT8;
case NUMTYPE.INT8:
return NUMTYPE.INT8;
case NUMTYPE.UINT16:
return NUMTYPE.UINT16
case NUMTYPE.INT16:
return NUMTYPE.INT16
// Everything else is discarded
default:
return NUMTYPE.UNKNOWN;
}
case NUMTYPE.FLOAT64:
switch (analysis.type) {
// FLOAT64 -> Anything 1-2 bytes
case NUMTYPE.UINT8:
return NUMTYPE.UINT8;
case NUMTYPE.INT8:
return NUMTYPE.INT8;
case NUMTYPE.UINT16:
return NUMTYPE.UINT16
case NUMTYPE.INT16:
return NUMTYPE.INT16
// FLOAT64 -> FLOAT32
case NUMTYPE.FLOAT32:
return NUMTYPE.FLOAT32
// Everything else is discarded
default:
return NUMTYPE.UNKNOWN;
}
}
}
|
javascript
|
{
"resource": ""
}
|
q5385
|
getBestBinFit
|
train
|
function getBestBinFit( start, len, blocks ) {
var b, s, e, end = start + len, found = false,
c, last_c = 0, last_s = 0, last_i = -1, last_bin = null;
// Find the biggest chunk that can fit on these data
for (var bi=0, bl=blocks.length; bi<bl; ++bi) {
b = blocks[bi]; found = false;
for (var i=0, il=b.length; i<il; ++i) {
s = b[i][0]; e = s + b[i][1];
// Find the common region of block-scan frame
if ( ((s >= start) && (s < end-1)) || // Start in bounds
((e >= start) && (e < end-1)) || // End in bounds
((s <= start) && (e >= end)) ) //
{
// Check bounds
if (s < start) s = start;
if (s > end-2) continue;
if (e > end) e = end;
if (s === e) continue;
// Test coverage
c = e - s;
if (c > last_c) {
last_c = c;
last_s = s;
last_bin = b[i];
found = true;
}
}
}
// Prefer priority to length across different blocks
// on the first block (repeated)
if ((bi === 0) && found)
return last_bin;
}
// Update bounds
if (last_bin) {
last_bin = last_bin.slice();
last_bin[0] = last_s;
last_bin[1] = last_c;
}
// Return last bin
return last_bin;
}
|
javascript
|
{
"resource": ""
}
|
q5386
|
downscaleType
|
train
|
function downscaleType( fromType, toType ) {
// Lookup conversion on the downscale table
for (var i=0; i<NUMTYPE_DOWNSCALE.FROM.length; ++i) {
if ( (NUMTYPE_DOWNSCALE.FROM[i] === fromType) &&
(NUMTYPE_DOWNSCALE.TO[i] === toType) )
return i;
}
// Nothing found
return undefined;
}
|
javascript
|
{
"resource": ""
}
|
q5387
|
deltaEncTypeInt
|
train
|
function deltaEncTypeInt( fromType, toType ) {
// Lookup conversion on the downscale table
for (var i=0; i<NUMTYPE_DELTA_INT.FROM.length; ++i) {
if ( (NUMTYPE_DELTA_INT.FROM[i] === fromType) &&
(NUMTYPE_DELTA_INT.TO[i] === toType) )
return i;
}
// Nothing found
return undefined;
}
|
javascript
|
{
"resource": ""
}
|
q5388
|
deltaEncTypeFloat
|
train
|
function deltaEncTypeFloat( fromType, toType ) {
// Lookup conversion on the downscale table
for (var i=0; i<NUMTYPE_DELTA_FLOAT.FROM.length; ++i) {
if ( (NUMTYPE_DELTA_FLOAT.FROM[i] === fromType) &&
(NUMTYPE_DELTA_FLOAT.TO[i] === toType) )
return i;
}
// Nothing found
return undefined;
}
|
javascript
|
{
"resource": ""
}
|
q5389
|
deltaEncodeIntegers
|
train
|
function deltaEncodeIntegers( array, numType ) {
var delta = new NUMTYPE_CLASS[numType]( array.length - 1 ), l = array[0];
for (var i=1; i<array.length; ++i) {
var v = array[i]; delta[i-1] = v - l; l = v;
}
return delta;
}
|
javascript
|
{
"resource": ""
}
|
q5390
|
convertArray
|
train
|
function convertArray( array, numType ) {
// Skip matching cases
if ( ((array instanceof Uint8Array) && (numType === NUMTYPE.UINT8)) ||
((array instanceof Int8Array) && (numType === NUMTYPE.INT8)) ||
((array instanceof Uint16Array) && (numType === NUMTYPE.UINT16)) ||
((array instanceof Int16Array) && (numType === NUMTYPE.INT16)) ||
((array instanceof Uint32Array) && (numType === NUMTYPE.UINT32)) ||
((array instanceof Int32Array) && (numType === NUMTYPE.INT32)) ||
((array instanceof Float32Array) && (numType === NUMTYPE.FLOAT32)) ||
((array instanceof Float64Array) && (numType === NUMTYPE.FLOAT64)) ) {
// Return as-is
return array;
}
// Convert
return new NUMTYPE_CLASS[numType]( array );
}
|
javascript
|
{
"resource": ""
}
|
q5391
|
mimeTypeFromFilename
|
train
|
function mimeTypeFromFilename( filename ) {
var ext = filename.split(".").pop().toLowerCase();
return mime.lookup(filename) || "application/octet-stream";
}
|
javascript
|
{
"resource": ""
}
|
q5392
|
bufferFromFile
|
train
|
function bufferFromFile( filename ) {
console.info( ("Loading "+filename).grey );
var buf = fs.readFileSync( filename ), // Load Buffer
ab = new ArrayBuffer( buf.length ), // Create an ArrayBuffer to fit the data
view = new Uint8Array(ab); // Create an Uint8Array view
// Copy buffer into view
for (var i = 0; i < buf.length; ++i)
view[i] = buf[i];
// Return buffer view
return view;
}
|
javascript
|
{
"resource": ""
}
|
q5393
|
pickStream
|
train
|
function pickStream(encoder, t) {
// Handle type
switch (t) {
case NUMTYPE.UINT8:
case NUMTYPE.INT8:
return encoder.stream8;
case NUMTYPE.UINT16:
case NUMTYPE.INT16:
return encoder.stream16;
case NUMTYPE.UINT32:
case NUMTYPE.INT32:
case NUMTYPE.FLOAT32:
return encoder.stream32;
case NUMTYPE.FLOAT64:
return encoder.stream64;
}
}
|
javascript
|
{
"resource": ""
}
|
q5394
|
encodeArray_NUM_DWS
|
train
|
function encodeArray_NUM_DWS( encoder, data, n_from, n_to ) {
//
// Downscaled Numeric Array (NUM_DWS)
//
// ... .... . + Data Length
// 000 [DWS_TYPE] [LN] [16bit/32bit]
//
// Get downscale type
var n_dws_type = downscaleType( n_from, n_to );
// console.log(">>>",data.constructor,":",_NUMTYPE[n_from],"->",_NUMTYPE[n_to],":",n_dws_type);
encoder.counters.arr_dws+=1;
encoder.log(LOG.ARR, "array.numeric.downscaled, len="+data.length+
", from="+_NUMTYPE[n_from]+", to="+_NUMTYPE[n_to]+
", type="+_NUMTYPE_DOWNSCALE_DWS[n_dws_type]+" ("+n_dws_type+")");
if (data.length < UINT16_MAX) { // 16-bit length prefix
encoder.stream8.write( pack1b( ARR_OP.NUM_DWS | NUMTYPE_LN.UINT16 | (n_dws_type << 1) ) );
encoder.stream16.write( pack2b( data.length, false ) );
encoder.counters.arr_hdr+=3;
} else { // 32-bit length prefix
encoder.stream8.write( pack1b( ARR_OP.NUM_DWS | NUMTYPE_LN.UINT32 | (n_dws_type << 1) ) );
encoder.stream32.write( pack4b( data.length, false ) );
encoder.counters.arr_hdr+=5;
}
// Encode value
pickStream( encoder, n_to )
.write( packTypedArray( convertArray( data, n_to ) ) );
}
|
javascript
|
{
"resource": ""
}
|
q5395
|
encodeArray_NUM_DELTA_FLOAT
|
train
|
function encodeArray_NUM_DELTA_FLOAT( encoder, data, n_from, n_to, pivot, f_scale ) {
//
// Pivot Float Numeric Array (NUM_DELTA_FLOAT)
//
// ... .... . + Data Length + Mean Value + Scale
// 001 [DWS_TYPE] [LN] [16bit/32bit] [F32/F64] [F32]
//
// Get downscale type
var n_delta_type = deltaEncTypeFloat( n_from, n_to );
if (n_delta_type === undefined) {
throw new Errors.EncodeError('Non-viable float delta value from '+_NUMTYPE[n_from]+' to '+_NUMTYPE[n_to]+'!');
}
encoder.counters.arr_delta_float+=1;
encoder.log(LOG.ARR, "array.numeric.delta.float, len="+data.length+
", from="+_NUMTYPE[n_from]+", to="+_NUMTYPE[n_to]+
", type="+_NUMTYPE_DOWNSCALE_DELTA_FLOAT[n_delta_type]+" ("+n_delta_type+")"+
", pivot="+pivot+", scale="+f_scale);
if (data.length < UINT16_MAX) { // 16-bit length prefix
encoder.stream8.write( pack1b( ARR_OP.NUM_DELTA_FLOAT | NUMTYPE_LN.UINT16 | (n_delta_type << 1) ) );
encoder.stream16.write( pack2b( data.length, false ) );
encoder.counters.arr_hdr+=3;
} else { // 32-bit length prefix
encoder.stream8.write( pack1b( ARR_OP.NUM_DELTA_FLOAT | NUMTYPE_LN.UINT32 | (n_delta_type << 1) ) );
encoder.stream32.write( pack4b( data.length, false ) );
encoder.counters.arr_hdr+=5;
}
// Write pivot value
pickStream( encoder, n_from )
.write( packByNumType[n_from]( pivot ) );
// Write scale
encoder.stream64.write( pack8f( f_scale ) );
// Pivot-encode floats
var pivot_array = new NUMTYPE_CLASS[n_to]( data.length );
for (var i=1; i<data.length; ++i) {
pivot_array[i] = (data[i] - pivot) / f_scale;
// console.log(">>>", data[i],"->", pivot_array[i]);
}
// Envode pivot array
pickStream( encoder, n_to)
.write( packTypedArray( pivot_array ) );
}
|
javascript
|
{
"resource": ""
}
|
q5396
|
encodeArray_NUM_DELTA_INT
|
train
|
function encodeArray_NUM_DELTA_INT( encoder, data, n_from, n_to ) {
//
// Delta Numeric Array (NUM_DELTA_INT)
//
// ... .... . + Data Length + Initial Value
// 001 [DWS_TYPE] [LN] [16bit/32bit] [8bit/16bit/32bit]
//
// Get downscale type
var n_delta_type = deltaEncTypeInt( n_from, n_to );
if (n_delta_type === undefined) {
throw new Errors.EncodeError('Non-viable integer delta value from '+_NUMTYPE[n_from]+' to '+_NUMTYPE[n_to]+'!');
}
encoder.counters.arr_delta_int+=1;
encoder.log(LOG.ARR, "array.numeric.delta.int, len="+data.length+
", from="+_NUMTYPE[n_from]+", to="+_NUMTYPE[n_to]+
", type="+_NUMTYPE_DOWNSCALE_DELTA_INT[n_delta_type]+" ("+n_delta_type+")");
if (data.length < UINT16_MAX) { // 16-bit length prefix
encoder.stream8.write( pack1b( ARR_OP.NUM_DELTA_INT | NUMTYPE_LN.UINT16 | (n_delta_type << 1) ) );
encoder.stream16.write( pack2b( data.length, false ) );
encoder.counters.arr_hdr+=3;
} else { // 32-bit length prefix
encoder.stream8.write( pack1b( ARR_OP.NUM_DELTA_INT | NUMTYPE_LN.UINT32 | (n_delta_type << 1) ) );
encoder.stream32.write( pack4b( data.length, false ) );
encoder.counters.arr_hdr+=5;
}
// Write initial value
pickStream( encoder, n_from )
.write( packByNumType[n_from]( data[0] ) );
// Delta-encode integers
pickStream( encoder, n_to)
.write( packTypedArray( deltaEncodeIntegers( data, n_to ) ) );
}
|
javascript
|
{
"resource": ""
}
|
q5397
|
encodeArray_NUM_REPEATED
|
train
|
function encodeArray_NUM_REPEATED( encoder, data, n_type ) {
//
// Repeated Numeric Array (NUM_REPEATED)
//
// .... ... . + Data Length
// 0100 [TYPE] [LN] [16bit/32bit]
//
encoder.counters.arr_num_repeated+=1;
encoder.log(LOG.ARR, "array.numeric.repeated, len="+data.length+
", type="+_NUMTYPE[n_type]+" ("+n_type+")");
if (data.length < UINT16_MAX) { // 16-bit length prefix
encoder.stream8.write( pack1b( ARR_OP.NUM_REPEATED | NUMTYPE_LN.UINT16 | (n_type << 1) ) );
encoder.stream16.write( pack2b( data.length, false ) );
encoder.counters.arr_hdr+=3;
} else { // 32-bit length prefix
encoder.stream8.write( pack1b( ARR_OP.NUM_REPEATED | NUMTYPE_LN.UINT32 | (n_type << 1) ) );
encoder.stream32.write( pack4b( data.length, false ) );
encoder.counters.arr_hdr+=5;
}
// Write initial value
pickStream( encoder, n_type )
.write( packByNumType[n_type]( data[0] ) );
}
|
javascript
|
{
"resource": ""
}
|
q5398
|
encodeArray_NUM_RAW
|
train
|
function encodeArray_NUM_RAW( encoder, data, n_type ) {
//
// RAW Numeric Array (NUM_RAW)
//
// .... ... . + Data Length
// 0101 [TYPE] [LN] [16bit/32bit]
//
encoder.counters.arr_num_raw+=1;
encoder.log(LOG.ARR, "array.numeric.raw, len="+data.length+
", type="+_NUMTYPE[n_type]+" ("+n_type+")");
if (data.length < UINT16_MAX) { // 16-bit length prefix
encoder.stream8.write( pack1b( ARR_OP.NUM_RAW | NUMTYPE_LN.UINT16 | (n_type << 1) ) );
encoder.stream16.write( pack2b( data.length, false ) );
encoder.counters.arr_hdr+=3;
} else { // 32-bit length prefix
encoder.stream8.write( pack1b( ARR_OP.NUM_RAW | NUMTYPE_LN.UINT32 | (n_type << 1) ) );
encoder.stream32.write( pack4b( data.length, false ) );
encoder.counters.arr_hdr+=5;
}
// Encode the short array
pickStream( encoder, n_type )
.write( packTypedArray( convertArray( data, n_type ) ) );
}
|
javascript
|
{
"resource": ""
}
|
q5399
|
encodeArray_NUM_SHORT
|
train
|
function encodeArray_NUM_SHORT( encoder, data, n_type ) {
//
// Short Numeric Array (NUM_SHORT)
//
// ..... ...
// 01110 [TYPE]
//
encoder.counters.arr_num_short+=1;
encoder.log(LOG.ARR, "array.numeric.short, len="+data.length+
", type="+_NUMTYPE[n_type]+" ("+n_type+")");
// Encode primitives one after the other
encoder.stream8.write( pack1b( ARR_OP.NUM_SHORT | n_type ) );
encoder.stream8.write( pack1b( data.length, false ) );
encoder.counters.arr_hdr+=2;
// Encode the short array
pickStream( encoder, n_type )
.write( packTypedArray( convertArray( data, n_type ) ) );
}
|
javascript
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.