_id
stringlengths 2
6
| title
stringlengths 0
58
| partition
stringclasses 3
values | text
stringlengths 52
373k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q55800
|
train
|
function (str, options)
{
options = options || { };
var optimize = options.optimize;
var optimizerList = [];
if (optimize)
{
var optimizeComplex;
var optimizeToString;
if (typeof optimize === 'object')
{
optimizeComplex = !!optimize.complexOpt;
optimizeToString = !!optimize.toStringOpt;
}
else
optimizeComplex = optimizeToString = true;
var optimizers = this.optimizers;
var optimizer;
if (optimizeComplex)
{
var complexOptimizers = optimizers.complex;
if (!complexOptimizers)
complexOptimizers = optimizers.complex = createEmpty();
for (var complex in COMPLEX)
{
var entry = COMPLEX[complex];
if (this.hasFeatures(entry.mask) && str.indexOf(complex) >= 0)
{
optimizer =
complexOptimizers[complex] ||
(
complexOptimizers[complex] =
getComplexOptimizer(this, complex, entry.definition)
);
optimizerList.push(optimizer);
}
}
}
if (optimizeToString)
{
optimizer =
optimizers.toString || (optimizers.toString = getToStringOptimizer(this));
optimizerList.push(optimizer);
}
}
var buffer =
new ScrewBuffer
(options.bond, options.forceString, this.maxGroupThreshold, optimizerList);
var firstSolution = options.firstSolution;
var maxLength = options.maxLength;
if (firstSolution)
{
buffer.append(firstSolution);
if (buffer.length > maxLength)
return;
}
var match;
var regExp = _RegExp(STR_TOKEN_PATTERN, 'g');
while (match = regExp.exec(str))
{
var token;
var solution;
if (token = match[2])
solution = this.resolveCharacter(token);
else
{
token = match[1];
solution = SIMPLE[token];
}
if (!buffer.append(solution) || buffer.length > maxLength)
return;
}
var result = _String(buffer);
if (!(result.length > maxLength))
return result;
}
|
javascript
|
{
"resource": ""
}
|
|
q55801
|
train
|
function (array, maxLength)
{
var result =
this.replaceStringArray(array, [FALSE_FREE_DELIMITER], null, false, maxLength);
return result;
}
|
javascript
|
{
"resource": ""
}
|
|
q55802
|
encode
|
train
|
function encode(input, options)
{
input = esToString(input);
options = options || { };
var features = options.features;
var runAsData;
var runAs = options.runAs;
if (runAs !== undefined)
runAsData = filterRunAs(runAs, 'runAs');
else
runAsData = filterRunAs(options.wrapWith, 'wrapWith');
var wrapper = runAsData[0];
var strategyNames = runAsData[1];
if (options.trimCode)
input = trimJS(input);
var perfInfo = options.perfInfo;
var encoder = getEncoder(features);
var output = encoder.exec(input, wrapper, strategyNames, perfInfo);
return output;
}
|
javascript
|
{
"resource": ""
}
|
q55803
|
MapOperation
|
train
|
function MapOperation() {
this.counters = { increment: [], remove : []};
this.maps = { modify: [], remove: []};
this.sets = { adds: [], removes: [], remove: []};
this.registers = { set: [], remove: [] };
this.flags = { set: [], remove: [] };
}
|
javascript
|
{
"resource": ""
}
|
q55804
|
train
|
function(key) {
this._removeAddsOrRemoves(this.counters.increment, key);
if (this.counters.remove.indexOf(key) === -1) {
this.counters.remove.push(key);
}
return this;
}
|
javascript
|
{
"resource": ""
}
|
|
q55805
|
train
|
function(key, value) {
this._removeRemove(this.sets.remove, key);
var op = this._getOp(this.sets.removes, key);
if (op) {
op.remove.push(value);
} else {
this.sets.removes.push({key: key, remove: [value]});
}
return this;
}
|
javascript
|
{
"resource": ""
}
|
|
q55806
|
train
|
function(key) {
this._removeAddsOrRemoves(this.sets.adds, key);
this._removeAddsOrRemoves(this.sets.removes, key);
if (this.sets.remove.indexOf(key) === -1) {
this.sets.remove.push(key);
}
return this;
}
|
javascript
|
{
"resource": ""
}
|
|
q55807
|
train
|
function(key, value) {
this._removeRemove(this.registers.remove, key);
var op = this._getOp(this.registers.set, key);
if (op) {
op.value = value;
} else {
this.registers.set.push({key: key, value: value});
}
return this;
}
|
javascript
|
{
"resource": ""
}
|
|
q55808
|
train
|
function(key) {
this._removeAddsOrRemoves(this.registers.set, key);
if (this.registers.remove.indexOf(key) === -1) {
this.registers.remove.push(key);
}
return this;
}
|
javascript
|
{
"resource": ""
}
|
|
q55809
|
train
|
function(key, state) {
this._removeRemove(this.flags.remove, key);
var op = this._getOp(this.flags.set, key);
if (op) {
op.state = state;
} else {
this.flags.set.push({key: key, state: state});
}
return this;
}
|
javascript
|
{
"resource": ""
}
|
|
q55810
|
train
|
function(key) {
this._removeAddsOrRemoves(this.flags.set, key);
if (this.flags.remove.indexOf(key) === -1) {
this.flags.remove.push(key);
}
return this;
}
|
javascript
|
{
"resource": ""
}
|
|
q55811
|
train
|
function(key) {
this._removeAddsOrRemoves(this.maps.modify, key);
if (this.maps.remove.indexOf(key) === -1) {
this.maps.remove.push(key);
}
return this;
}
|
javascript
|
{
"resource": ""
}
|
|
q55812
|
train
|
function(nodes) {
for (var i = 0; i < nodes.length; i++) {
if (nodes[i] instanceof RiakNode) {
this.nodes.push(nodes[i]);
}
}
return this;
}
|
javascript
|
{
"resource": ""
}
|
|
q55813
|
finishRelease
|
train
|
function finishRelease() {
log.done();
execSync("npm run examples", {stdio: "inherit"});
execSync("npm run docs", {stdio: "inherit"});
let commits = "", releaseUrl = "", zipSize = 0;
log.timer("compiling release notes");
execAsync("git log --pretty=format:'* %s (%h)' `git describe --tags --abbrev=0`...HEAD")
.then(stdout => {
commits = stdout;
log.timer("publishing npm package");
return execAsync("npm publish ./");
})
.then(() => {
log.timer("commiting all modified files for release");
return execAsync("git add --all");
})
.then(() => execAsync(`git commit -m \"compiles v${version}\"`))
.then(() => {
log.timer("tagging latest commit");
return execAsync(`git tag v${version}`);
})
.then(() => {
log.timer("pushing to repository");
return execAsync("git push origin --follow-tags");
})
.then(() => {
log.timer("publishing release notes");
github.authenticate({type: "oauth", token});
return github.repos.createRelease({
owner: "d3plus",
repo: name,
tag_name: `v${version}`,
name: `v${version}`,
body: commits,
prerelease
});
})
.then(() => {
log.timer("attaching .zip distribution to release");
return github.repos.getReleaseByTag({
owner: "d3plus",
repo: name,
tag: `v${version}`
});
})
.then(release => {
releaseUrl = release.data.upload_url;
zipSize = fs.statSync(`build/${name}.zip`).size;
return github.repos.uploadAsset({
url: releaseUrl,
file: fs.createReadStream(`build/${name}.zip`),
contentType: "application/zip",
contentLength: zipSize,
name: `${name}.zip`,
label: `${name}.zip`,
owner: "d3plus",
repo: name
});
})
.then(() => {
log.exit();
shell.exit(0);
})
.catch(err => {
log.fail(err);
log.exit();
shell.exit(1);
});
}
|
javascript
|
{
"resource": ""
}
|
q55814
|
initBuffer
|
train
|
function initBuffer(data) {
// Create a new buffer to receive data if needed
if (buffer === null) {
buffer = new ByteBuffer(initBufferSize);
}
buffer.append(data);
buffer.flip();
}
|
javascript
|
{
"resource": ""
}
|
q55815
|
train
|
function (addresses, options) {
var riakNodes = [];
if (options === undefined) {
options = {};
}
for (var i = 0; i < addresses.length; i++) {
var split = addresses[i].split(':');
options.remoteAddress = split[0];
if (split.length === 2) {
options.remotePort = split[1];
}
riakNodes.push(new RiakNode(options));
}
return riakNodes;
}
|
javascript
|
{
"resource": ""
}
|
|
q55816
|
execAsync
|
train
|
function execAsync(cmd, opts = {}) {
return new Promise((resolve, reject) => {
shell.exec(cmd, opts, (code, stdout, stderr) => {
if (code !== 0) return reject(new Error(stderr));
return resolve(stdout);
});
});
}
|
javascript
|
{
"resource": ""
}
|
q55817
|
CommandBase
|
train
|
function CommandBase(pbRequestName, pbResponseName, callback) {
var requestCode = ProtoBufFactory.getCodeFor(pbRequestName);
this.expectedCode = ProtoBufFactory.getCodeFor(pbResponseName);
this.pbBuilder = ProtoBufFactory.getProtoFor(pbRequestName);
var schema = Joi.func().required();
var self = this;
Joi.validate(callback, schema, function(err, option) {
if (err) {
throw new Error('callback is required and must be a function');
}
self.callback = callback;
});
this.header = new Buffer(5);
this.header.writeUInt8(requestCode, 4);
this.remainingTries = 1;
// This is to facilitate debugging what pb messages this Command represents
this.name = util.format('%s-%d', pbRequestName, cid);
cid++;
this.validateOptions = function (arg_options, arg_schema, arg_joi_opts) {
var self = this;
Joi.validate(arg_options, arg_schema, arg_joi_opts, function(err, opts) {
if (err) {
throw err;
}
self.options = opts;
});
};
}
|
javascript
|
{
"resource": ""
}
|
q55818
|
ByKeyBase
|
train
|
function ByKeyBase(options, pbRequestName, pbResponseName, callback) {
CommandBase.call(this, pbRequestName, pbResponseName, callback);
this.validateOptions(options, schema);
}
|
javascript
|
{
"resource": ""
}
|
q55819
|
train
|
function(indexName, key) {
if (this.indexes === undefined) {
this.indexes = {};
}
if (!this.indexes.hasOwnProperty(indexName)) {
this.indexes[indexName] = [];
}
for (var i = 1; i < arguments.length; i++) {
this.indexes[indexName].push(arguments[i]);
}
return this;
}
|
javascript
|
{
"resource": ""
}
|
|
q55820
|
encodeBlocks
|
train
|
function encodeBlocks($, prefix, blockType, args, block) {
if (!prefix) prefix = "";
if (blockType == "function") {
// decode the function block (THIS IS THE IMPORTANT BIT)
// We are retrieving all sub-blocks and will re-parse them in light
// of newly shrunk variables
block = args + decodeBlocks(block, SCOPED);
prefix = prefix.replace(BRACKETS, "");
// create the list of variable and argument names
args = args.slice(1, -1);
if (args != "_no_shrink_") {
var vars = match(block, VARS).join(";").replace(VAR_g, ";var");
while (BRACKETS.test(vars)) {
vars = vars.replace(BRACKETS_g, "");
}
vars = vars.replace(VAR_TIDY, "").replace(VAR_EQUAL, "");
}
block = decodeBlocks(block, ENCODED_BLOCK);
// process each identifier
if (args != "_no_shrink_") {
var count = 0, shortId;
var ids = match([args, vars], IDENTIFIER);
var processed = {};
for (var i = 0; i < ids.length; i++) {
id = ids[i];
if (!processed["#" + id]) {
processed["#" + id] = true;
id = rescape(id);
// encode variable names
while (new RegExp(Shrinker.PREFIX + count + "\\b").test(block)) count++;
var reg = new RegExp("([^\\w$.])" + id + "([^\\w$:])");
while (reg.test(block)) {
block = block.replace(global(reg), "$1" + Shrinker.PREFIX + count + "$2");
}
var reg = new RegExp("([^{,\\w$.])" + id + ":", "g");
block = block.replace(reg, "$1" + Shrinker.PREFIX + count + ":");
count++;
}
}
total = Math.max(total, count);
}
var replacement = prefix + "~" + blocks.length + "~";
blocks.push(block);
} else {
var replacement = "~#" + blocks.length + "~";
blocks.push(prefix + block);
}
return replacement;
}
|
javascript
|
{
"resource": ""
}
|
q55821
|
decodeBlocks
|
train
|
function decodeBlocks(script, encoded) {
while (encoded.test(script)) {
script = script.replace(global(encoded), function(match, index) {
return blocks[index];
});
}
return script;
}
|
javascript
|
{
"resource": ""
}
|
q55822
|
parseShortcode
|
train
|
function parseShortcode(innerShortcode) {
var trimmedInnerShortcode = innerShortcode.trim();
// If no shortcode, it was blank between the blocks - return nothing.
if (!trimmedInnerShortcode) return;
// If no whitespace, then shortcode is just name with no attributes.
if (!hasWhiteSpace(trimmedInnerShortcode)) {
return { identifier: trimmedInnerShortcode, attributes: {} };
}
var splitShortcode = trimmedInnerShortcode.match(/^(\S+)\s(.*)/).slice(1);
var shortcodeName = splitShortcode[0];
var attributeString = splitShortcode[1];
var attributes = parseShortcodeAttributes(attributeString);
// If no attributes parsed, something went wrong - return nothing.
if (!attributes) return;
return {
identifier: shortcodeName,
attributes: attributes
};
}
|
javascript
|
{
"resource": ""
}
|
q55823
|
_Array_forEach
|
train
|
function _Array_forEach(array, block, context) {
if (array == null) array = global;
var length = array.length || 0, i; // preserve length
if (typeof array == "string") {
for (i = 0; i < length; i++) {
block.call(context, array.charAt(i), i, array);
}
} else { // Cater for sparse arrays.
for (i = 0; i < length; i++) {
/*@cc_on @*/
/*@if (@_jscript_version < 5.2)
if ($Legacy.has(array, i))
@else @*/
if (i in array)
/*@end @*/
block.call(context, array[i], i, array);
}
}
}
|
javascript
|
{
"resource": ""
}
|
q55824
|
train
|
function() {
if(file.revOrigPath) {
rimraf(file.revOrigPath, function(err) {
if (err) return cb(err);
cb(null, file);
});
} else {
cb(null);
}
}
|
javascript
|
{
"resource": ""
}
|
|
q55825
|
train
|
function(message) {
// Send notification as a proactive message
var activity = message.activity
var reference = TurnContext.getConversationReference(activity);
MicrosoftAppCredentials.trustServiceUrl(activity.serviceUrl);
adapter.continueConversation(reference, async (context) => {
// Complete the job.
await bot.processChatResponse(context, message);
});
}
|
javascript
|
{
"resource": ""
}
|
|
q55826
|
sendMessage
|
train
|
function sendMessage() {
var cache = [];
var args = [].slice.call(arguments);
// Safe stringifying of cyclical JSON
function decycle(key, val) {
if (typeof val === 'object' && val !== null) {
if (cache.indexOf(val) >= 0) return;
cache.push(val);
}
return val;
}
alert(JSON.stringify(args, decycle));
}
|
javascript
|
{
"resource": ""
}
|
q55827
|
decycle
|
train
|
function decycle(key, val) {
if (typeof val === 'object' && val !== null) {
if (cache.indexOf(val) >= 0) return;
cache.push(val);
}
return val;
}
|
javascript
|
{
"resource": ""
}
|
q55828
|
createGruntListener
|
train
|
function createGruntListener(ev, runner) {
runner.on(ev, function(test, err) {
var data = {
err: err
};
if (test) {
data.title = test.title;
data.fullTitle = test.fullTitle();
data.state = test.state;
data.duration = test.duration;
data.slow = test.slow;
data.pending = test.isPending();
}
sendMessage('mocha.' + ev, data);
});
}
|
javascript
|
{
"resource": ""
}
|
q55829
|
train
|
function(err) {
var stats = runner.stats;
testStats.push(stats);
if (err) {
// Show Growl notice
// @TODO: Get an example of this
// growl('PhantomJS Error!');
// If there was a PhantomJS error, abort the series.
grunt.fatal(err);
done(false);
} else {
// If failures, show growl notice
if (stats.failures > 0) {
var reduced = helpers.reduceStats([stats]);
var failMsg = reduced.failures + '/' + reduced.tests +
' tests failed (' + reduced.duration + 's)';
// Show Growl notice, if avail
growl(failMsg, {
image: asset('growl/error.png'),
title: 'Failure in ' + grunt.task.current.target,
priority: 3
});
// Bail tests if bail option is true
if (options.bail) grunt.warn(failMsg);
}
// Process next file/url
next();
}
}
|
javascript
|
{
"resource": ""
}
|
|
q55830
|
train
|
function(arg) {
var args = Array.isArray(arg) ? arg : [].slice.call(arguments);
last = new Date();
fs.write(tmpfile, JSON.stringify(args) + '\n', 'a');
}
|
javascript
|
{
"resource": ""
}
|
|
q55831
|
bluemixServiceLookup
|
train
|
function bluemixServiceLookup(options, verbose) {
var result = false;
if (process.env.VCAP_SERVICES) {
if (verbose) console.log('VCAP_SERVICES variable present in environment');
var services = JSON.parse(process.env.VCAP_SERVICES);
for (var key in services) {
if (key.lastIndexOf(mqlightServiceName, 0) === 0) {
var mqlightService = services[key][0];
options.service = mqlightService.credentials.connectionLookupURI;
options.user = mqlightService.credentials.username;
options.password = mqlightService.credentials.password;
} else if (key.lastIndexOf(messageHubServiceName, 0) === 0) {
var messageHubService = services[key][0];
options.service = messageHubService.credentials.mqlight_lookup_url;
options.user = messageHubService.credentials.user;
options.password = messageHubService.credentials.password;
}
}
if (!options.hasOwnProperty('service') ||
!options.hasOwnProperty('user') ||
!options.hasOwnProperty('password')) {
throw 'Error - Check that app is bound to service';
}
result = true;
} else if (verbose) {
console.log('VCAP_SERVICES variable not present in environment');
}
return result;
}
|
javascript
|
{
"resource": ""
}
|
q55832
|
setupError
|
train
|
function setupError(obj, name, message) {
if (obj) {
Error.call(obj);
Object.defineProperty(obj, 'name', {
value: name,
enumerable: false
});
Object.defineProperty(obj, 'message', {
value: message,
enumerable: false
});
} else {
logger.ffdc('setupError', 'ffdc001', null, 'Client object not provided');
}
}
|
javascript
|
{
"resource": ""
}
|
q55833
|
getNamedError
|
train
|
function getNamedError(obj) {
if (obj && obj instanceof Error && 'name' in obj) {
var Constructor = exports[obj.name];
if (typeof Constructor === 'function') {
var res = new Constructor(obj.message);
if (res) {
res.stack = obj.stack;
return res;
}
}
}
return obj;
}
|
javascript
|
{
"resource": ""
}
|
q55834
|
shouldReconnect
|
train
|
function shouldReconnect(err) {
// exclude all programming errors
return (!(err instanceof TypeError) &&
!(err instanceof InvalidArgumentError) &&
!(err instanceof NotPermittedError) &&
!(err instanceof ReplacedError) &&
!(err instanceof StoppedError) &&
!(err instanceof SubscribedError) &&
!(err instanceof UnsubscribedError)
);
}
|
javascript
|
{
"resource": ""
}
|
q55835
|
train
|
function(fileUrl) {
logger.entry('getFileServiceFunction', logger.NO_CLIENT_ID);
logger.log('parms', logger.NO_CLIENT_ID, 'fileUrl:', fileUrl);
if (typeof fileUrl !== 'string') {
var err = new TypeError('fileUrl must be a string type');
logger.ffdc('getFileServiceFunction', 'ffdc001', null, err);
logger.throw('getFileServiceFunction', logger.NO_CLIENT_ID, err);
throw err;
}
var filePath = fileUrl;
// special case for Windows drive letters in file URIs, trim the leading /
if (os.platform() === 'win32' && filePath.match('^/[a-zA-Z]:/')) {
filePath = filePath.substring(1);
}
var fileServiceFunction = function(callback) {
logger.entry('fileServiceFunction', logger.NO_CLIENT_ID);
logger.log('parms', logger.NO_CLIENT_ID, 'filePath:', filePath);
fs.readFile(filePath, {encoding: 'utf8'}, function(err, data) {
logger.entry('fileServiceFunction.readFile.callback',
logger.NO_CLIENT_ID);
logger.log('parms', logger.NO_CLIENT_ID, 'err:', err);
logger.log('parms', logger.NO_CLIENT_ID, 'data:', data);
if (err) {
err.message = 'attempt to read ' + filePath + ' failed with the ' +
'following error: ' + err.message;
logger.log('error', logger.NO_CLIENT_ID, err);
logger.entry('fileServiceFunction.callback', logger.NO_CLIENT_ID);
logger.log('parms', logger.NO_CLIENT_ID, 'err:', err);
callback(err);
logger.exit('fileServiceFunction.callback', logger.NO_CLIENT_ID, null);
} else {
var obj;
try {
obj = JSON.parse(data);
} catch (err) {
err.message = 'the content read from ' + filePath + ' contained ' +
'unparseable JSON: ' + err.message;
logger.caught('fileServiceFunction.readFile.callback',
logger.NO_CLIENT_ID, err);
logger.entry('fileServiceFunction.callback', logger.NO_CLIENT_ID);
logger.log('parms', logger.NO_CLIENT_ID, 'err:', err);
callback(err);
logger.exit('fileServiceFunction.callback', logger.NO_CLIENT_ID,
null);
}
if (obj) {
logger.entry('fileServiceFunction.callback', logger.NO_CLIENT_ID);
logger.log('parms', logger.NO_CLIENT_ID, 'service:', obj.service);
callback(null, obj.service);
logger.exit('fileServiceFunction.callback', logger.NO_CLIENT_ID,
null);
}
}
logger.exit('fileServiceFunction.readFile.callback', logger.NO_CLIENT_ID,
null);
});
logger.exit('fileServiceFunction', logger.NO_CLIENT_ID, null);
};
logger.exit('getFileServiceFunction', logger.NO_CLIENT_ID,
fileServiceFunction);
return fileServiceFunction;
}
|
javascript
|
{
"resource": ""
}
|
|
q55836
|
train
|
function(client) {
if (typeof client === 'undefined'/* || client.constructor !== Client*/) {
logger.entry('Client.reconnect', logger.NO_CLIENT_ID);
logger.log('parms', logger.NO_CLIENT_ID, 'client:', client);
logger.exit('Client.reconnect', logger.NO_CLIENT_ID, undefined);
return;
}
logger.entry('Client.reconnect', client.id);
if (client.state !== STATE_STARTED) {
if (client.isStopped()) {
logger.exit('Client.reconnect', client.id, null);
return;
} else if (client.state === STATE_RETRYING) {
logger.exit('Client.reconnect', client.id, client);
return client;
}
}
client._setState(STATE_RETRYING);
setImmediate(function() {
// stop the messenger to free the object then attempt a reconnect
stopMessenger(client, function(client) {
logger.entry('Client.reconnect.stopProcessing', client.id);
// clear the subscriptions list, if the cause of the reconnect happens
// during check for messages we need a 0 length so it will check once
// reconnected.
logger.log('data', client.id, 'client._subscriptions:',
client._subscriptions);
while (client._subscriptions.length > 0) {
client._queuedSubscriptions.push(client._subscriptions.shift());
}
// also clear any left over outstanding sends
while (client._outstandingSends.length > 0) {
client._outstandingSends.shift();
}
client._queuedStartCallbacks.push({
callback: processQueuedActions,
create: false
});
process.nextTick(function() {
client._performConnect(false, true);
});
logger.exit('Client.reconnect.stopProcessing', client.id, null);
});
});
logger.exit('Client.reconnect', client.id, client);
return client;
}
|
javascript
|
{
"resource": ""
}
|
|
q55837
|
train
|
function(error) {
logger.entry('Client._tryService.tryNextService', _id);
if (serviceList.length === 1) {
// We've tried all services without success. Pause for a while
// before trying again
logger.log('data', _id, 'End of service list');
client._setState(STATE_RETRYING);
var retry = function() {
logger.entryLevel('entry_often', 'Client._tryService.retry', _id);
if (!client.isStopped()) {
process.nextTick(function() {
client._performConnect(false, true);
});
}
logger.exitLevel('exit_often', 'Client._tryService.retry',
_id, null);
};
client._retryCount++;
var retryCap = 60000;
// Limit to the power of 8 as anything above this will put the
// interval higher than the cap straight away.
var exponent = (client._retryCount <= 8) ? client._retryCount : 8;
var upperBound = Math.pow(2, exponent);
var lowerBound = 0.75 * upperBound;
var jitter = Math.random() * (0.25 * upperBound);
var interval = Math.min(retryCap, (lowerBound + jitter) * 1000);
// times by CONNECT_RETRY_INTERVAL for unittest purposes
interval = Math.round(interval) * CONNECT_RETRY_INTERVAL;
logger.log('data', _id, 'trying to connect again ' +
'after ' + (interval / 1000) + ' seconds');
setTimeout(retry, interval);
if (error) {
setImmediate(function() {
logger.log('emit', _id, 'error', error);
client.emit('error', error);
});
}
} else {
// Try the next service in the list
logger.log('data', _id, 'Trying next service');
client._tryService(serviceList.slice(1));
}
logger.exit('Client._tryService.tryNextService', _id, null);
}
|
javascript
|
{
"resource": ""
}
|
|
q55838
|
train
|
function(err) {
logger.entry('Client._tryService.connError', _id);
err = lookupError(err);
logger.log('data', _id, 'failed to connect to: ' + logUrl +
' due to error: ' + util.inspect(err));
// This service failed to connect. Try the next one.
// XXX: wrap in shouldReconnect ?
tryNextService(err);
logger.exit('Client._tryService.connError', _id, null);
}
|
javascript
|
{
"resource": ""
}
|
|
q55839
|
meta_data_still_fresh
|
train
|
function meta_data_still_fresh(item) {
var promise = read_meta_data(item).
then(function(item) {
return new Promise(function(resolve, reject) {
if (headers_still_fresh(item.meta_data.headers)) {
resolve(item);
} else {
reject(item);
}
});
});
return promise;
}
|
javascript
|
{
"resource": ""
}
|
q55840
|
ModelType
|
train
|
function ModelType(name, prefix, endp) {
this.name = name;
this.prefix = prefix;
this.endp = endp;
}
|
javascript
|
{
"resource": ""
}
|
q55841
|
getDataBasedOnCatalog
|
train
|
function getDataBasedOnCatalog(options, catalogs, models, cb) {
async.each(catalogs,
function(catalog, catcallback) {
/* Next, go to APIs for each catalog */
async.each(models,
function(model, modelcallback) {
pullDataFromEndp(options, catalog, model, function(err) {
if (err) {
logger.error(err);
}
modelcallback(err);
});
},
function(err) {
catcallback(err);
});
},
function(err) {
cb(err, response);
}
);
}
|
javascript
|
{
"resource": ""
}
|
q55842
|
fetchFromCache
|
train
|
function fetchFromCache(options, opts, cb) {
// look for existing cached resource
if (indirFiles.length > 0) {
var etag;
var regexp = '^' + opts.prefix +
'([A-Za-z0-9]+={0,2})' + // base64 encoded
opts.suffix + '$';
var regex = new RegExp(regexp);
var i;
for (i = 0; i < indirFiles.length; i++) {
var file = regex.exec(indirFiles[i]);
if (file) {
etag = new Buffer(file[1], 'base64').toString();
break;
}
}
if (etag) {
try {
var headOpts = JSON.parse(JSON.stringify(options)); // clone options
headOpts.headers = { 'If-None-Match': etag };
request.head(headOpts, function(err, res, body) {
if (err) {
logger.error(err);
cb();
// not fatal; continue
} else if (res.statusCode === 304) {
var filename = path.join(opts.outdir, indirFiles[i]);
fs.copy(path.join(opts.indir, indirFiles[i]),
filename,
{ preserveTimestamps: true },
function(err) {
if (err) {
throw (err);
}
var body = decryptData(fs.readFileSync(filename));
logger.info('Using cached copy of %s', indirFiles[i]);
var result = {
file: filename,
contents: body };
cb(null, result);
});
} else {
cb();
}
});
} catch (e) {
logger.error(e);
cb();
// not fatal; continue
}
} else {
cb();
}
} else {
cb();
}
}
|
javascript
|
{
"resource": ""
}
|
q55843
|
train
|
function(callback) {
stageModels(app, models, function(err) {
models.pop(); // remove snapshot model
models.pop(); // remove optimizedData model
callback(err);
});
}
|
javascript
|
{
"resource": ""
}
|
|
q55844
|
train
|
function(err) {
if (!err) {
loadData(app, apimanager, models, true, uid);
}
if (!apimanager.host) {
//monitor the file changes, load data again if any changes
fs.watch(definitionsDir, function(event, filename) {
if (filename !== '.datastore') {
logger.debug('File changed in %s%s, reload data', definitionsDir, filename);
loadData(app, apimanager, models, false, uid);
}
});
}
}
|
javascript
|
{
"resource": ""
}
|
|
q55845
|
loadData
|
train
|
function loadData(app, apimanager, models, reload, uid) {
var currdir = getPreviousSnapshotDir();
var snapdir;
var snapshotID = getSnapshotID();
var populatedSnapshot = false;
async.series([
function(callback) {
logger.debug('apimanager before pullFromAPIm: %j', apimanager);
if (apimanager.host) {
// && apimanager.handshakeOk << shouldn't call if handshake failed.. not ready #TODO
// && apimanager.webhooksOk << shouldn't call if handshake failed.. not ready #TODO
// don't look for successful handshake/webhooks currently because UT depends on this
// we have an APIm, handshake succeeded, so try to pull data..
pullFromAPIm(apimanager, currdir, snapshotID, function(err, dir) {
if (err) {
if (uid) {
snapshotID = uid;
} // in case of error, try the previous snapshot
}
snapdir = dir; // even in case of error, we need to try loading from the file system
callback();
});
} else {
snapdir = '';
callback();
}
},
// populate snapshot model
function(callback) {
populateSnapshot(app, snapshotID, callback);
},
// load current config
function(callback) {
populatedSnapshot = true;
loadConfig(app,
apimanager,
models,
currdir,
snapdir,
snapshotID,
callback);
} ],
function(err, results) {
if (!reload) {
return;
}
var interval = apimanager.maxRefresh;
// if no error and APIs specified, do not agressively reload config
if (!err && apimanager.host && (http || https)) {
apimanager.startupRefresh = interval;
// if the previous snapshot hasn't be loaded, delete it
if (uid && snapshotID !== uid) {
try {
fs.removeSync(currdir);
} catch (e) {
logger.error(e);
//continue
}
}
} else if (apimanager.startupRefresh < apimanager.maxRefresh) {
// try agressively at first, and slowly back off
interval = apimanager.startupRefresh;
apimanager.startupRefresh *= 2;
}
if (err) {
if (populatedSnapshot) {
releaseSnapshot(app, snapshotID, function(err) {
if (err) { /* suppress eslint handle-callback-err */ }
process.send({ LOADED: false });
});
} else {
process.send({ LOADED: false });
}
} else if (!apimanager.host || http || https) {
// neither http nor https would be set if there were no APIs
// defined; if no APIs defined, let's try again in a while
process.send({ LOADED: true, https: https });
}
setImmediate(scheduleLoadData,
app,
interval,
apimanager,
models);
});
}
|
javascript
|
{
"resource": ""
}
|
q55846
|
train
|
function(callback) {
populatedSnapshot = true;
loadConfig(app,
apimanager,
models,
currdir,
snapdir,
snapshotID,
callback);
}
|
javascript
|
{
"resource": ""
}
|
|
q55847
|
stageModels
|
train
|
function stageModels(app, models, cb) {
logger.debug('stageModels entry');
async.forEach(models,
function(model, callback) {
app.dataSources.db.automigrate(
model.name,
function(err) {
callback(err);
}
);
},
function(err) {
logger.debug('stageModels exit');
cb(err);
}
);
}
|
javascript
|
{
"resource": ""
}
|
q55848
|
addSignatureHeaders
|
train
|
function addSignatureHeaders(body, headers, keyId, private_key) {
var sign = function(str, private_key) {
var sign = Crypto.createSign('RSA-SHA256');
sign.update(str);
return sign.sign(private_key, 'base64');
};
var sha256 = function(str, encoding) {
var bodyStr = JSON.stringify(str);
var hash = Crypto.createHash('sha256');
hash.update(bodyStr);
return hash.digest(encoding);
};
if (!headers) {
headers = {};
}
if (!headers.date) {
headers.date = (new Date()).toUTCString();
}
if (!headers.digest) {
headers.digest = 'SHA256=' + sha256(body, 'base64');
}
var combine = function(names, headers) {
var parts = [];
names.forEach(function(e) {
parts.push(e + ': ' + headers[e]);
});
return parts.join('\n');
};
headers.authorization = 'Signature ' +
'keyId="' + keyId + '", ' +
'headers="date digest", ' +
'algorithm="rsa-sha256", ' +
'signature="' + sign(combine([ 'date', 'digest' ], headers), private_key) + '"';
return headers;
}
|
javascript
|
{
"resource": ""
}
|
q55849
|
handshakeWithAPIm
|
train
|
function handshakeWithAPIm(app, apimanager, private_key, cb) {
logger.debug('handshakeWithAPIm entry');
async.series([
function(callback) {
var body = JSON.stringify({ gatewayVersion: version });
var headers = { 'content-type': 'application/json' };
addSignatureHeaders(body, headers, 'micro-gw-catalog/' + apimanager.catalog, private_key);
if (logger.debug()) {
logger.debug(JSON.stringify(headers, null, 2));
}
var apimHandshakeUrlObj = {
protocol: 'https',
hostname: apimanager.host,
port: apimanager.port,
pathname: '/v1/catalogs/' + apimanager.catalog + '/handshake/' };
var apimHandshakeUrl = url.format(apimHandshakeUrlObj);
Request(
{ url: apimHandshakeUrl,
method: 'POST',
json: body,
headers: headers,
agentOptions: {
//FIXME: need to eventually remove this
rejectUnauthorized: false } },
function(err, res, body) {
if (err) {
logger.error('Failed to communicate with %s: %s ', apimHandshakeUrl, err);
return callback(err);
}
logger.debug('statusCode: ' + res.statusCode);
if (res.statusCode !== 200) {
logger.error(apimHandshakeUrl, ' failed with: ', res.statusCode);
return callback(new Error(apimHandshakeUrl + ' failed with: ' + res.statusCode));
}
var json = decryptAPIMResponse(body, private_key);
//sensitive data
//if (logger.debug()) {
// logger.debug(JSON.stringify(json, null, 2));
//}
if (!json.microGateway) {
return callback(new Error(apimHandshakeUrl + ' response did not contain "microGateway" section'));
}
var ugw = json.microGateway;
apimanager.clicert = ugw.cert;
apimanager.clikey = ugw.key;
apimanager.clientid = ugw.clientID;
//sensitive data
//if (logger.debug()) {
// logger.debug('apimanager: %s', JSON.stringify(apimanager, null, 2));
//}
callback(null);
});
} ],
function(err) {
if (err) {
apimanager.handshakeOk = false;
logger.error('Unsuccessful handshake with API Connect server');
} else {
apimanager.handshakeOk = true;
logger.info('Successful handshake with API Connect server');
}
logger.debug('handshakeWithAPIm exit');
cb(err);
});
}
|
javascript
|
{
"resource": ""
}
|
q55850
|
pullFromAPIm
|
train
|
function pullFromAPIm(apimanager, currdir, uid, cb) {
logger.debug('pullFromAPIm entry');
// Have an APIm, grab latest if we can..
var snapdir = path.join(process.env.ROOTCONFIGDIR, uid);
fs.mkdirs(snapdir, function(err) {
if (err) {
logger.warn('Failed to create snapshot directory');
logger.debug('pullFromAPIm exit(1)');
cb(err, '');
return;
}
/*
var options = {
host: host of APIm
port: port of APIm
timeout: opts.timeout * 1000 || 30 * 1000,
clikey: opts.clikey ? opts.clikey : null,
clicert: opts.clicert ? opts.clicert : null,
clientid: opts.clientid || '1111-1111',
outdir: opts.outdir || 'apim' };
*/
var options = {};
options.host = apimanager.host;
options.port = apimanager.port;
options.clikey = apimanager.clikey;
options.clicert = apimanager.clicert;
options.clientid = apimanager.clientid;
options.indir = currdir;
options.outdir = snapdir;
logger.debug('apimpull start');
apimpull(options, function(err, response) {
if (err) {
logger.error(err);
try {
fs.removeSync(snapdir);
} catch (e) {
logger.error(e);
//continue
}
snapdir = '';
// falling through
// try loading from local files
} else {
logger.info('Successfully pulled snapshot from API Connect server');
}
logger.debug(response);
logger.debug('pullFromAPIm exit(2)');
cb(err, snapdir);
});
});
}
|
javascript
|
{
"resource": ""
}
|
q55851
|
loadConfig
|
train
|
function loadConfig(app, apimanager, models, currdir, snapdir, uid, cb) {
logger.debug('loadConfig entry');
var dirToLoad = (snapdir === '') ? currdir : snapdir;
loadConfigFromFS(app, apimanager, models, dirToLoad, uid, function(err) {
if (err) {
logger.error(err);
logger.debug('loadConfig error(1)');
cb(err);
return;
} else if (mixedProtocols) {
logger.debug('loadConfig error(2)');
cb(new Error('mixed protocols'));
return;
} else {
// update current snapshot pointer
updateSnapshot(app, uid, function(err) {
if (err) {
logger.debug('loadConfig error(3)');
cb(err);
return;
}
// only update pointer to latest configuration
// when latest configuration successful loaded
if (snapdir === dirToLoad) {
process.env[CONFIGDIR] = snapdir;
setPreviousSnapshotDir(snapdir);
}
logger.debug('loadConfig exit');
cb();
});
}
});
}
|
javascript
|
{
"resource": ""
}
|
q55852
|
loadConfigFromFS
|
train
|
function loadConfigFromFS(app, apimanager, models, dir, uid, cb) {
// clear out existing files from model structure
models.forEach(
function(model) {
model.files = [];
}
);
if (apimanager.host) {
var files = [];
logger.debug('loadConfigFromFS entry');
try {
if (dir !== '') {
files = fs.readdirSync(dir);
}
} catch (e) {
logger.error('Failed to read directory: ', dir);
cb(e);
return;
}
logger.debug('files: ', files);
var jsonFile = new RegExp(/.*\.json$/);
// correlate files with appropriate model
files.forEach(
function(file) {
logger.debug('file match jsonFile: ', file.match(jsonFile));
if (file.match(jsonFile)) {
for (var i = 0; i < models.length; i++) {
if (file.indexOf(models[i].prefix) > -1) {
logger.debug('%s file: %s', models[i].name, file);
models[i].files.push(file);
break;
}
}
}
}
);
// populate data-store models with the file contents
populateModelsWithAPImData(app, models, dir, uid, cb);
} else {
var YAMLfiles = [];
logger.debug('dir: ', dir);
//read the apic settings
var cfg = readApicConfig(dir);
//read the YAML files
project.loadProject(dir).then(function(artifacts) {
logger.debug('%j', artifacts);
artifacts.forEach(
function(artifact) {
if (artifact.type === 'swagger') {
YAMLfiles.push(artifact.filePath);
}
});
// populate data-store models with the file contents
populateModelsWithLocalData(app, YAMLfiles, cfg, dir, uid, cb);
});
}
}
|
javascript
|
{
"resource": ""
}
|
q55853
|
train
|
function(seriesCallback) {
async.forEach(YAMLfiles,
function(file, fileCallback) {
logger.debug('Loading data from %s', file);
var readfile;
try {
// read the content of the files into memory and parse as JSON
readfile = YAML.load(fs.readFileSync(file, 'utf8'));
} catch (e) {
fileCallback(e);
return;
}
var model = {};
var entry = {};
// looks like a product
if (readfile.product) {
logger.debug('product found: skipping');
}
// looks like an API
if (readfile.swagger) {
entry.id = createAPIID(readfile);
entry.document = expandAPIData(readfile, dir);
if (entry.document) {
model.name = 'api';
if (entry.document.info['x-ibm-name']) {
apis[entry.document.info['x-ibm-name']] = entry.document;
} else {
apis[entry.document.info['title']] = entry.document;
}
}
}
if (model.name) {
// no catalog
entry.catalog = {};
entry['snapshot-id'] = uid;
app.models[model.name].create(
entry,
function(err, mymodel) {
if (err) {
logger.error(err);
fileCallback(err);
return;
}
logger.debug('%s created: %j', model.name, mymodel);
fileCallback();
});
} else {
fileCallback();
}
},
function(err) {
if (err) { /* suppress eslint handle-callback-err */ }
}
);
seriesCallback();
}
|
javascript
|
{
"resource": ""
}
|
|
q55854
|
train
|
function(seriesCallback) {
defaultCatalog['snapshot-id'] = uid;
app.models['catalog'].create(
defaultCatalog,
function(err, mymodel) {
if (err) {
logger.error(err);
seriesCallback(err);
return;
}
logger.debug('%s created: %j', 'catalog', mymodel);
seriesCallback();
});
}
|
javascript
|
{
"resource": ""
}
|
|
q55855
|
train
|
function(seriesCallback) {
var entry = {};
// add catalog
entry.catalog = defaultCatalog;
entry['snapshot-id'] = uid;
entry.document = {
product: '1.0.0',
info: {
name: 'static-product',
version: '1.0.0',
title: 'static-product' },
visibility: {
view: {
type: 'public' },
subscribe: {
type: 'authenticated' } },
apis: apis };
var rateLimit = '100/hour';
if (process.env[LAPTOP_RATELIMIT]) {
rateLimit = process.env[LAPTOP_RATELIMIT];
}
if (apicCfg && apicCfg.plans && apicCfg.applications) {
//add the configured plans
entry.document.plans = {};
//add plan and its APIs
for (var p in apicCfg.plans) {
var plan = apicCfg.plans[p];
if (typeof plan === 'object') {
var planApis = {};
for (var i in plan.apis) {
var name = plan.apis[i];
//add the api to plan if only if the api does exist
if (apis[name]) {
planApis[name] = {};
} else {
logger.warn('Cannot add the invalid api "%s" to plan "%s"',
name, p);
}
}
entry.document.plans[p] = {
apis: planApis,
'rate-limit': {
value: plan['rate-limit'] || rateLimit,
'hard-limit': plan['hard-limit'] } };
}
}
} else {
//the default plan
entry.document.plans = {
default: {
apis: apis,
'rate-limit': {
value: rateLimit,
'hard-limit': true } } };
}
if (logger.debug()) {
logger.debug('creating static product and attaching apis to plans: %s',
JSON.stringify(entry, null, 2));
}
app.models.product.create(
entry,
function(err, mymodel) {
if (err) {
logger.error(err);
seriesCallback(err);
return;
}
logger.debug('%s created: %j', 'product', mymodel);
seriesCallback();
});
}
|
javascript
|
{
"resource": ""
}
|
|
q55856
|
train
|
function(seriesCallback) {
var subscriptions = [];
if (apicCfg && apicCfg.plans && apicCfg.applications) {
//add the configured plans
var idx = 0;
for (var k in apicCfg.applications) {
var theApp = apicCfg.applications[k];
//An application can subscribe only one plan in a given product. Since
//we have only one product defined for local data, the subscription of
//an app should be a string instead of array!
if (theApp && (!theApp.subscription || typeof theApp.subscription !== 'string')) {
logger.warn('The app "%s" does not subscribe a plan?', k);
} else if (typeof theApp === 'object') {
subscriptions[idx] = {
'snapshot-id': uid,
organization: defaultOrg,
'developer-organization': defaultOrg,
catalog: defaultCatalog,
id: 'defaultSubsID-' + k + '-static-product',
application: {
id: 'defaultAppID-' + k,
title: 'defaultAppTitle-' + idx,
'oauth-redirection-uri': (theApp['oauth-redirection-uri'] || 'https://localhost'),
'app-credentials': [ {
'client-id': k,
'client-secret': (theApp['client-secret'] || 'dummy') } ] },
'plan-registration': {
id: ('static-product:1.0.0:' + theApp.subscription) } };
}
idx++;
}
} else {
//the default subscription
subscriptions[0] = {
'snapshot-id': uid,
organization: defaultOrg,
'developer-organization': defaultOrg,
catalog: defaultCatalog,
id: 'defaultSubsID',
application: {
id: 'defaultAppID',
title: 'defaultAppTitle',
'oauth-redirection-uri': 'https://localhost',
'app-credentials': [ {
'client-id': 'default',
'client-secret': 'CRexOpCRkV1UtjNvRZCVOczkUrNmGyHzhkGKJXiDswo=' } ] },
'plan-registration': {
id: 'ALLPLANS' } };
}
async.forEach(
subscriptions,
function(subscription, subsCallback) {
var modelname = 'subscription';
app.models[modelname].create(
subscription,
function(err, mymodel) {
if (err) {
logger.error(err);
subsCallback(err);
return;
}
logger.debug('%s created: %j', modelname, mymodel);
subsCallback();
});
});
seriesCallback();
}
|
javascript
|
{
"resource": ""
}
|
|
q55857
|
train
|
function(seriesCallback) {
var modelname = 'tlsprofile';
async.forEachOf(
apicCfg['tls-profiles'],
function(profile, name, asyncCB) {
var instance = {
'snapshot-id': uid,
'org-id': defaultOrg.id,
id: 'defaultTlsProfile-' + name,
name: name,
public: false,
ciphers: [
'SSL_RSA_WITH_AES_256_CBC_SHA',
'SSL_RSA_WITH_AES_128_CBC_SHA',
'SSL_RSA_WITH_3DES_EDE_CBC_SHA',
'SSL_RSA_WITH_RCA_128_SHA',
'SSL_RSA_WITH_RCA_128_MD5' ],
protocols: [ 'TLSv11', 'TLSv12' ],
certs: [],
'mutual-auth': false };
if (profile.rejectUnauthorized === true) {
instance['mutual-auth'] = true;
}
if (Array.isArray(profile.secureProtocols)) {
instance.protocols = [];
profile.secureProtocols.forEach(function(protocol) {
switch (protocol) {
case 'TLSv1_method':
instance.protocols.push('TLSv1');
break;
case 'TLSv1_1_method':
instance.protocols.push('TLSv11');
break;
case 'TLSv1_2_method':
instance.protocols.push('TLSv12');
break;
}
});
}
if (typeof profile.key === 'object') {
instance['private-key'] = profile.key.content;
}
if (typeof profile.cert === 'object') {
instance.certs.push({
name: profile.cert.name,
cert: profile.cert.content,
'cert-type': 'INTERMEDIATE',
'cert-id': name + '-cert-' + profile.cert.name });
}
if (Array.isArray(profile.ca)) {
profile.ca.forEach(function(ca) {
if (typeof ca === 'object') {
instance.certs.push({
name: ca.name,
cert: ca.content,
'cert-type': 'CLIENT',
'cert-id': name + '-ca-cert-' + ca.name });
}
});
}
app.models[modelname].create(
instance,
function(err, mymodel) {
if (err) {
logger.error('Failed to populate a tls-profile:', err);
} else {
logger.debug('%s created: %j', modelname, mymodel);
}
asyncCB();
});
});
seriesCallback();
}
|
javascript
|
{
"resource": ""
}
|
|
q55858
|
populateSnapshot
|
train
|
function populateSnapshot(app, uid, cb) {
logger.debug('populateSnapshot entry');
app.models.snapshot.create(
{ id: uid,
refcount: '1',
current: 'false' },
function(err, mymodel) {
if (err) {
logger.error('populateSnapshot error');
cb(err);
return;
}
logger.debug('populateSnapshot exit: %j', mymodel);
cb();
});
}
|
javascript
|
{
"resource": ""
}
|
q55859
|
releaseSnapshot
|
train
|
function releaseSnapshot(app, uid, cb) {
logger.debug('releaseSnapshot entry');
app.models.snapshot.release(uid,
function(err) {
if (err) {
logger.error(err);
}
logger.debug('releaseSnapshot exit');
if (cb) {
cb(err);
}
});
}
|
javascript
|
{
"resource": ""
}
|
q55860
|
updateSnapshot
|
train
|
function updateSnapshot(app, uid, cb) {
logger.debug('updateSnapshot entry');
app.models.snapshot.findOne(
{ where: { current: 'true' } },
function(err, instance) {
if (err) {
// fall through assuming there was no current
} else if (instance) {
instance.updateAttributes(
{ current: 'false' },
function(err, instance) {
if (err) {
// fall through assuming instance was deleted
}
});
releaseSnapshot(app, instance.id);
}
});
app.models.snapshot.findById(uid, function(err, instance) {
if (err) {
logger.debug('updateSnapshot error(1)');
cb(err);
return;
}
instance.updateAttributes(
{ current: 'true' },
function(err, instance) {
if (err) {
logger.debug('updateSnapshot error(2)');
cb(err);
return;
}
logger.debug('updateSnapshot exit');
cb();
});
});
}
|
javascript
|
{
"resource": ""
}
|
q55861
|
getOpParams
|
train
|
function getOpParams(pathParams, opParams) {
var unionParams = _.unionWith(opParams, pathParams, opParamComparator);
return unionParams;
}
|
javascript
|
{
"resource": ""
}
|
q55862
|
free
|
train
|
function free(key) {
if (locks[key]) {
delete locks[key];
stats.lock_remove();
}
tick(key);
}
|
javascript
|
{
"resource": ""
}
|
q55863
|
tick
|
train
|
function tick(key) {
var next;
if (waiting[key]) {
//there's somone waiting for this resource
if (!locks[key]) {
locks[key] = true;
stats.lock_add();
next = waiting[key].shift();
if (waiting[key].length === 0) {
//nobody is waiting for this resource anymore, clean it up
delete waiting[key];
}
next(key);
}
}
}
|
javascript
|
{
"resource": ""
}
|
q55864
|
wait
|
train
|
function wait(key, cb) {
if (!waiting[key]) {
waiting[key] = [];
}
waiting[key].push(cb);
}
|
javascript
|
{
"resource": ""
}
|
q55865
|
lock
|
train
|
function lock(key) {
var promise = new Promise(function(resolve, reject) {
wait(key, function(key) {
var released = false;
var lock = function() {
if (!released) {
free(key);
released = true;
}
};
lock.key = key;
resolve(lock);
});
});
tick(key);
return promise;
}
|
javascript
|
{
"resource": ""
}
|
q55866
|
check
|
train
|
async function check(){
if (broker.emitter.open <= 0) return true;
else {
this.logger.warn("Event queue not empty... waiting", {queue: broker.emitter.open});
throw "Retry";
}
}
|
javascript
|
{
"resource": ""
}
|
q55867
|
isPropertyRequired
|
train
|
function isPropertyRequired(property, requiredArray) {
var found = false;
requiredArray = requiredArray || [];
requiredArray.forEach(function(requiredProperty) {
if (requiredProperty === property) {
found = true;
}
});
return found;
}
|
javascript
|
{
"resource": ""
}
|
q55868
|
instantiatePrimitive
|
train
|
function instantiatePrimitive(val) {
var type = val.type;
// Support for default values in the JSON Schema.
if (val.hasOwnProperty('default')) {
return val.default;
}
return typesInstantiator[type];
}
|
javascript
|
{
"resource": ""
}
|
q55869
|
getObjectType
|
train
|
function getObjectType(obj) {
// Check if type is array of types.
if (isArray(obj.type)) {
obj.type = obj.type[0];
}
return obj.type;
}
|
javascript
|
{
"resource": ""
}
|
q55870
|
findDefinition
|
train
|
function findDefinition(schema, ref) {
var propertyPath = ref.split('/').slice(1); // Ignore the #/uri at the beginning.
var currentProperty = propertyPath.splice(0, 1)[0];
var currentValue = schema;
while (currentProperty) {
currentValue = currentValue[currentProperty];
currentProperty = propertyPath.splice(0, 1)[0];
}
return currentValue;
}
|
javascript
|
{
"resource": ""
}
|
q55871
|
instantiate
|
train
|
function instantiate(schema, options) {
options = options || {};
/**
* Visits each sub-object using recursion.
* If it reaches a primitive, instantiate it.
* @param obj - The object that represents the schema.
* @param name - The name of the current object.
* @param data - The instance data that represents the current object.
*/
function visit(obj, name, data) {
if (!obj) {
return;
}
var i;
var type = getObjectType(obj);
// We want non-primitives objects (primitive === object w/o properties).
if (type === 'object' && obj.properties) {
data[name] = data[name] || { };
// Visit each property.
for (var property in obj.properties) {
if (obj.properties.hasOwnProperty(property)) {
if (shouldVisit(property, obj, options)) {
visit(obj.properties[property], property, data[name]);
}
}
}
} else if (obj.allOf) {
for (i = 0; i < obj.allOf.length; i++) {
visit(obj.allOf[i], name, data);
}
} else if (obj.$ref) {
obj = findDefinition(schema, obj.$ref);
visit(obj, name, data);
} else if (type === 'array') {
data[name] = [];
var len = 0;
if (obj.minItems || obj.minItems > 0) {
len = obj.minItems;
}
// Instantiate 'len' items.
for (i = 0; i < len; i++) {
visit(obj.items, i, data[name]);
}
} else if (isEnum(obj)) {
data[name] = instantiateEnum(obj);
} else if (isPrimitive(obj)) {
data[name] = instantiatePrimitive(obj);
}
}
var data = {};
visit(schema, 'kek', data);
return data['kek'];
}
|
javascript
|
{
"resource": ""
}
|
q55872
|
train
|
function(options) {
if (config.sourcemaps) {
options = _.defaults(
options,
{ devtool: '#source-map' }
);
}
if (config.production) {
var currPlugins = _.isArray(options.plugins) ? options.plugins : [];
options.plugins = currPlugins.concat([new UglifyJsPlugin({ sourceMap: false })]);
}
return options;
}
|
javascript
|
{
"resource": ""
}
|
|
q55873
|
getRule
|
train
|
function getRule(commitlintConfig, ruleName) {
const rule = commitlintConfig.rules[ruleName];
if (rule) {
return {
raw: rule,
level: rule[0],
applicable: rule[1],
value: rule[2],
};
}
}
|
javascript
|
{
"resource": ""
}
|
q55874
|
reportIsValid
|
train
|
function reportIsValid(report = {}) {
return report.valid && report.errors.length === 0 && report.warnings.length === 0;
}
|
javascript
|
{
"resource": ""
}
|
q55875
|
reportSummary
|
train
|
function reportSummary(report = {}) {
if (reportIsValid(report)) {
return '';
}
const countErrors = report.errors.length;
const countWarnings = report.warnings.length;
const color = countErrors > 0 ? 'red' : 'yellow';
const summaries = [];
const issues = [];
if (countErrors > 0) {
summaries.push(chalk`{red ${countErrors}} ${countErrors === 1 ? 'error' : 'errors'}`);
report.errors.forEach(error => {
issues.push(chalk` {bold.red -} ${error.message} {dim ${error.name}}`);
});
}
if (countWarnings > 0) {
summaries.push(chalk`{yellow ${countWarnings}} ${countWarnings === 1 ? 'warning' : 'warnings'}`);
report.warnings.forEach(warning => {
issues.push(chalk` {bold.yellow -} ${warning.message} {dim ${warning.name}}`);
});
}
const summary = summaries.length > 0 ? chalk`{dim ${summaries.join(', ')}}` : '';
const header = chalk`{bold.${color} !} {bold Final commit violates conventions} ${summary}`;
const footer = chalk`{dim aborted commit}`;
return `${header}\n${issues.join('\n')}\n\n ${footer}`;
}
|
javascript
|
{
"resource": ""
}
|
q55876
|
connect
|
train
|
function connect() {
var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
var callback = arguments[1];
this.host = props.host || '127.0.0.1';
this.port = props.port || 21000;
this.resultType = props.resultType || null;
this.timeout = props.timeout || 1000;
this.transport = props.transport || _thrift2.default.TBufferedTransport;
this.protocol = props.protocol || _thrift2.default.TBinaryProtocol;
this.options = {
transport: this.transport,
protocol: this.protocol,
timeout: this.timeout
};
var deferred = _thrift.Q.defer();
var connection = _thrift2.default.createConnection(this.host, this.port, this.options);
var client = _thrift2.default.createClient(_ImpalaService2.default, connection);
connection.on('error', ImpalaClient.onErrorDeferred(deferred));
connection.on('connect', function () {
deferred.resolve('Connection is established.');
});
this.client = client;
this.connection = connection;
deferred.promise.nodeify(callback);
return deferred.promise;
}
|
javascript
|
{
"resource": ""
}
|
q55877
|
mkdir_p
|
train
|
function mkdir_p (path, mode, callback, position) {
var parts = require('path').normalize(path).split(osSep);
mode = mode || process.umask();
position = position || 0;
if (position >= parts.length) {
return callback();
}
var directory = parts.slice(0, position + 1).join(osSep) || osSep;
fs.stat(directory, function(err) {
if (err === null) {
mkdir_p(path, mode, callback, position + 1);
} else {
mkdirOrig(directory, mode, function (err) {
if (err && err.code != 'EEXIST') {
return callback(err);
} else {
mkdir_p(path, mode, callback, position + 1);
}
});
}
});
}
|
javascript
|
{
"resource": ""
}
|
q55878
|
RemoteLS
|
train
|
function RemoteLS (opts) {
var _this = this
_.extend(this, {
logger: console,
development: true, // include dev dependencies.
optional: true, // include optional dependencies.
peer: false, // include peer dependencies.
verbose: false,
registry: require('registry-url')(), // URL of registry to ls.
queue: async.queue(function (task, done) {
_this._loadPackageJson(task, done)
}, 8),
tree: {},
flat: {}
}, require('./config')(), opts)
this.queue.pause()
}
|
javascript
|
{
"resource": ""
}
|
q55879
|
_fnAddColumn
|
train
|
function _fnAddColumn( oSettings, nTh )
{
var oDefaults = DataTable.defaults.columns;
var iCol = oSettings.aoColumns.length;
var oCol = $.extend( {}, DataTable.models.oColumn, oDefaults, {
"sSortingClass": oSettings.oClasses.sSortable,
"sSortingClassJUI": oSettings.oClasses.sSortJUI,
"nTh": nTh ? nTh : document.createElement('th'),
"sTitle": oDefaults.sTitle ? oDefaults.sTitle : nTh ? nTh.innerHTML : '',
"aDataSort": oDefaults.aDataSort ? oDefaults.aDataSort : [iCol],
"mDataProp": oDefaults.mDataProp ? oDefaults.oDefaults : iCol
} );
oSettings.aoColumns.push( oCol );
/* Add a column specific filter */
if ( oSettings.aoPreSearchCols[ iCol ] === undefined || oSettings.aoPreSearchCols[ iCol ] === null )
{
oSettings.aoPreSearchCols[ iCol ] = $.extend( {}, DataTable.models.oSearch );
}
else
{
var oPre = oSettings.aoPreSearchCols[ iCol ];
/* Don't require that the user must specify bRegex, bSmart or bCaseInsensitive */
if ( oPre.bRegex === undefined )
{
oPre.bRegex = true;
}
if ( oPre.bSmart === undefined )
{
oPre.bSmart = true;
}
if ( oPre.bCaseInsensitive === undefined )
{
oPre.bCaseInsensitive = true;
}
}
/* Use the column options function to initialise classes etc */
_fnColumnOptions( oSettings, iCol, null );
}
|
javascript
|
{
"resource": ""
}
|
q55880
|
_fnVisbleColumns
|
train
|
function _fnVisbleColumns( oS )
{
var iVis = 0;
for ( var i=0 ; i<oS.aoColumns.length ; i++ )
{
if ( oS.aoColumns[i].bVisible === true )
{
iVis++;
}
}
return iVis;
}
|
javascript
|
{
"resource": ""
}
|
q55881
|
_fnDetectType
|
train
|
function _fnDetectType( sData )
{
var aTypes = DataTable.ext.aTypes;
var iLen = aTypes.length;
for ( var i=0 ; i<iLen ; i++ )
{
var sType = aTypes[i]( sData );
if ( sType !== null )
{
return sType;
}
}
return 'string';
}
|
javascript
|
{
"resource": ""
}
|
q55882
|
_fnReOrderIndex
|
train
|
function _fnReOrderIndex ( oSettings, sColumns )
{
var aColumns = sColumns.split(',');
var aiReturn = [];
for ( var i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ )
{
for ( var j=0 ; j<iLen ; j++ )
{
if ( oSettings.aoColumns[i].sName == aColumns[j] )
{
aiReturn.push( j );
break;
}
}
}
return aiReturn;
}
|
javascript
|
{
"resource": ""
}
|
q55883
|
_fnColumnOrdering
|
train
|
function _fnColumnOrdering ( oSettings )
{
var sNames = '';
for ( var i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ )
{
sNames += oSettings.aoColumns[i].sName+',';
}
if ( sNames.length == iLen )
{
return "";
}
return sNames.slice(0, -1);
}
|
javascript
|
{
"resource": ""
}
|
q55884
|
_fnGetRowData
|
train
|
function _fnGetRowData( oSettings, iRow, sSpecific )
{
var out = [];
for ( var i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ )
{
out.push( _fnGetCellData( oSettings, iRow, i, sSpecific ) );
}
return out;
}
|
javascript
|
{
"resource": ""
}
|
q55885
|
_fnSetCellData
|
train
|
function _fnSetCellData( oSettings, iRow, iCol, val )
{
var oCol = oSettings.aoColumns[iCol];
var oData = oSettings.aoData[iRow]._aData;
oCol.fnSetData( oData, val );
}
|
javascript
|
{
"resource": ""
}
|
q55886
|
_fnGetDataMaster
|
train
|
function _fnGetDataMaster ( oSettings )
{
var aData = [];
var iLen = oSettings.aoData.length;
for ( var i=0 ; i<iLen; i++ )
{
aData.push( oSettings.aoData[i]._aData );
}
return aData;
}
|
javascript
|
{
"resource": ""
}
|
q55887
|
_fnGetUniqueThs
|
train
|
function _fnGetUniqueThs ( oSettings, nHeader, aLayout )
{
var aReturn = [];
if ( !aLayout )
{
aLayout = oSettings.aoHeader;
if ( nHeader )
{
aLayout = [];
_fnDetectHeader( aLayout, nHeader );
}
}
for ( var i=0, iLen=aLayout.length ; i<iLen ; i++ )
{
for ( var j=0, jLen=aLayout[i].length ; j<jLen ; j++ )
{
if ( aLayout[i][j].unique &&
(!aReturn[j] || !oSettings.bSortCellsTop) )
{
aReturn[j] = aLayout[i][j].cell;
}
}
}
return aReturn;
}
|
javascript
|
{
"resource": ""
}
|
q55888
|
_fnBuildSearchArray
|
train
|
function _fnBuildSearchArray ( oSettings, iMaster )
{
if ( !oSettings.oFeatures.bServerSide )
{
/* Clear out the old data */
oSettings.asDataSearch.splice( 0, oSettings.asDataSearch.length );
var aArray = (iMaster && iMaster===1) ?
oSettings.aiDisplayMaster : oSettings.aiDisplay;
for ( var i=0, iLen=aArray.length ; i<iLen ; i++ )
{
oSettings.asDataSearch[i] = _fnBuildSearchRow( oSettings,
_fnGetRowData( oSettings, aArray[i], 'filter' ) );
}
}
}
|
javascript
|
{
"resource": ""
}
|
q55889
|
_fnBuildSearchRow
|
train
|
function _fnBuildSearchRow( oSettings, aData )
{
var sSearch = '';
if ( oSettings.__nTmpFilter === undefined )
{
oSettings.__nTmpFilter = document.createElement('div');
}
var nTmp = oSettings.__nTmpFilter;
for ( var j=0, jLen=oSettings.aoColumns.length ; j<jLen ; j++ )
{
if ( oSettings.aoColumns[j].bSearchable )
{
var sData = aData[j];
sSearch += _fnDataToSearch( sData, oSettings.aoColumns[j].sType )+' ';
}
}
/* If it looks like there is an HTML entity in the string, attempt to decode it */
if ( sSearch.indexOf('&') !== -1 )
{
nTmp.innerHTML = sSearch;
sSearch = nTmp.textContent ? nTmp.textContent : nTmp.innerText;
/* IE and Opera appear to put an newline where there is a <br> tag - remove it */
sSearch = sSearch.replace(/\n/g," ").replace(/\r/g,"");
}
return sSearch;
}
|
javascript
|
{
"resource": ""
}
|
q55890
|
_fnDataToSearch
|
train
|
function _fnDataToSearch ( sData, sType )
{
if ( typeof DataTable.ext.ofnSearch[sType] === "function" )
{
return DataTable.ext.ofnSearch[sType]( sData );
}
else if ( sData === null )
{
return '';
}
else if ( sType == "html" )
{
return sData.replace(/[\r\n]/g," ").replace( /<.*?>/g, "" );
}
else if ( typeof sData === "string" )
{
return sData.replace(/[\r\n]/g," ");
}
return sData;
}
|
javascript
|
{
"resource": ""
}
|
q55891
|
_fnEscapeRegex
|
train
|
function _fnEscapeRegex ( sVal )
{
var acEscape = [ '/', '.', '*', '+', '?', '|', '(', ')', '[', ']', '{', '}', '\\', '$', '^' ];
var reReplace = new RegExp( '(\\' + acEscape.join('|\\') + ')', 'g' );
return sVal.replace(reReplace, '\\$1');
}
|
javascript
|
{
"resource": ""
}
|
q55892
|
_fnCalculateEnd
|
train
|
function _fnCalculateEnd( oSettings )
{
if ( oSettings.oFeatures.bPaginate === false )
{
oSettings._iDisplayEnd = oSettings.aiDisplay.length;
}
else
{
/* Set the end point of the display - based on how many elements there are
* still to display
*/
if ( oSettings._iDisplayStart + oSettings._iDisplayLength > oSettings.aiDisplay.length ||
oSettings._iDisplayLength == -1 )
{
oSettings._iDisplayEnd = oSettings.aiDisplay.length;
}
else
{
oSettings._iDisplayEnd = oSettings._iDisplayStart + oSettings._iDisplayLength;
}
}
}
|
javascript
|
{
"resource": ""
}
|
q55893
|
_fnScrollingWidthAdjust
|
train
|
function _fnScrollingWidthAdjust ( oSettings, n )
{
if ( oSettings.oScroll.sX === "" && oSettings.oScroll.sY !== "" )
{
/* When y-scrolling only, we want to remove the width of the scroll bar so the table
* + scroll bar will fit into the area avaialble.
*/
var iOrigWidth = $(n).width();
n.style.width = _fnStringToCss( $(n).outerWidth()-oSettings.oScroll.iBarWidth );
}
else if ( oSettings.oScroll.sX !== "" )
{
/* When x-scrolling both ways, fix the table at it's current size, without adjusting */
n.style.width = _fnStringToCss( $(n).outerWidth() );
}
}
|
javascript
|
{
"resource": ""
}
|
q55894
|
_fnSaveState
|
train
|
function _fnSaveState ( oSettings )
{
if ( !oSettings.oFeatures.bStateSave || oSettings.bDestroying )
{
return;
}
/* Store the interesting variables */
var i, iLen, bInfinite=oSettings.oScroll.bInfinite;
var oState = {
"iCreate": new Date().getTime(),
"iStart": (bInfinite ? 0 : oSettings._iDisplayStart),
"iEnd": (bInfinite ? oSettings._iDisplayLength : oSettings._iDisplayEnd),
"iLength": oSettings._iDisplayLength,
"aaSorting": $.extend( true, [], oSettings.aaSorting ),
"oSearch": $.extend( true, {}, oSettings.oPreviousSearch ),
"aoSearchCols": $.extend( true, [], oSettings.aoPreSearchCols ),
"abVisCols": []
};
for ( i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ )
{
oState.abVisCols.push( oSettings.aoColumns[i].bVisible );
}
_fnCallbackFire( oSettings, "aoStateSaveParams", 'stateSaveParams', [oSettings, oState] );
oSettings.fnStateSave.call( oSettings.oInstance, oSettings, oState );
}
|
javascript
|
{
"resource": ""
}
|
q55895
|
_fnLoadState
|
train
|
function _fnLoadState ( oSettings, oInit )
{
if ( !oSettings.oFeatures.bStateSave )
{
return;
}
var oData = oSettings.fnStateLoad.call( oSettings.oInstance, oSettings );
if ( !oData )
{
return;
}
/* Allow custom and plug-in manipulation functions to alter the saved data set and
* cancelling of loading by returning false
*/
var abStateLoad = _fnCallbackFire( oSettings, 'aoStateLoadParams', 'stateLoadParams', [oSettings, oData] );
if ( $.inArray( false, abStateLoad ) !== -1 )
{
return;
}
/* Store the saved state so it might be accessed at any time */
oSettings.oLoadedState = $.extend( true, {}, oData );
/* Restore key features */
oSettings._iDisplayStart = oData.iStart;
oSettings.iInitDisplayStart = oData.iStart;
oSettings._iDisplayEnd = oData.iEnd;
oSettings._iDisplayLength = oData.iLength;
oSettings.aaSorting = oData.aaSorting.slice();
oSettings.saved_aaSorting = oData.aaSorting.slice();
/* Search filtering */
$.extend( oSettings.oPreviousSearch, oData.oSearch );
$.extend( true, oSettings.aoPreSearchCols, oData.aoSearchCols );
/* Column visibility state
* Pass back visibiliy settings to the init handler, but to do not here override
* the init object that the user might have passed in
*/
oInit.saved_aoColumns = [];
for ( var i=0 ; i<oData.abVisCols.length ; i++ )
{
oInit.saved_aoColumns[i] = {};
oInit.saved_aoColumns[i].bVisible = oData.abVisCols[i];
}
_fnCallbackFire( oSettings, 'aoStateLoaded', 'stateLoaded', [oSettings, oData] );
}
|
javascript
|
{
"resource": ""
}
|
q55896
|
_fnCreateCookie
|
train
|
function _fnCreateCookie ( sName, sValue, iSecs, sBaseName, fnCallback )
{
var date = new Date();
date.setTime( date.getTime()+(iSecs*1000) );
/*
* Shocking but true - it would appear IE has major issues with having the path not having
* a trailing slash on it. We need the cookie to be available based on the path, so we
* have to append the file name to the cookie name. Appalling. Thanks to vex for adding the
* patch to use at least some of the path
*/
var aParts = window.location.pathname.split('/');
var sNameFile = sName + '_' + aParts.pop().replace(/[\/:]/g,"").toLowerCase();
var sFullCookie, oData;
if ( fnCallback !== null )
{
oData = (typeof $.parseJSON === 'function') ?
$.parseJSON( sValue ) : eval( '('+sValue+')' );
sFullCookie = fnCallback( sNameFile, oData, date.toGMTString(),
aParts.join('/')+"/" );
}
else
{
sFullCookie = sNameFile + "=" + encodeURIComponent(sValue) +
"; expires=" + date.toGMTString() +"; path=" + aParts.join('/')+"/";
}
/* Are we going to go over the cookie limit of 4KiB? If so, try to delete a cookies
* belonging to DataTables. This is FAR from bullet proof
*/
var sOldName="", iOldTime=9999999999999;
var iLength = _fnReadCookie( sNameFile )!==null ? document.cookie.length :
sFullCookie.length + document.cookie.length;
if ( iLength+10 > 4096 ) /* Magic 10 for padding */
{
var aCookies =document.cookie.split(';');
for ( var i=0, iLen=aCookies.length ; i<iLen ; i++ )
{
if ( aCookies[i].indexOf( sBaseName ) != -1 )
{
/* It's a DataTables cookie, so eval it and check the time stamp */
var aSplitCookie = aCookies[i].split('=');
try { oData = eval( '('+decodeURIComponent(aSplitCookie[1])+')' ); }
catch( e ) { continue; }
if ( oData.iCreate && oData.iCreate < iOldTime )
{
sOldName = aSplitCookie[0];
iOldTime = oData.iCreate;
}
}
}
if ( sOldName !== "" )
{
document.cookie = sOldName+"=; expires=Thu, 01-Jan-1970 00:00:01 GMT; path="+
aParts.join('/') + "/";
}
}
document.cookie = sFullCookie;
}
|
javascript
|
{
"resource": ""
}
|
q55897
|
_fnReadCookie
|
train
|
function _fnReadCookie ( sName )
{
var
aParts = window.location.pathname.split('/'),
sNameEQ = sName + '_' + aParts[aParts.length-1].replace(/[\/:]/g,"").toLowerCase() + '=',
sCookieContents = document.cookie.split(';');
for( var i=0 ; i<sCookieContents.length ; i++ )
{
var c = sCookieContents[i];
while (c.charAt(0)==' ')
{
c = c.substring(1,c.length);
}
if (c.indexOf(sNameEQ) === 0)
{
return decodeURIComponent( c.substring(sNameEQ.length,c.length) );
}
}
return null;
}
|
javascript
|
{
"resource": ""
}
|
q55898
|
_fnGetTrNodes
|
train
|
function _fnGetTrNodes ( oSettings )
{
var aNodes = [];
var aoData = oSettings.aoData;
for ( var i=0, iLen=aoData.length ; i<iLen ; i++ )
{
if ( aoData[i].nTr !== null )
{
aNodes.push( aoData[i].nTr );
}
}
return aNodes;
}
|
javascript
|
{
"resource": ""
}
|
q55899
|
_fnGetTdNodes
|
train
|
function _fnGetTdNodes ( oSettings, iIndividualRow )
{
var anReturn = [];
var iCorrector;
var anTds;
var iRow, iRows=oSettings.aoData.length,
iColumn, iColumns, oData, sNodeName, iStart=0, iEnd=iRows;
/* Allow the collection to be limited to just one row */
if ( iIndividualRow !== undefined )
{
iStart = iIndividualRow;
iEnd = iIndividualRow+1;
}
for ( iRow=iStart ; iRow<iEnd ; iRow++ )
{
oData = oSettings.aoData[iRow];
if ( oData.nTr !== null )
{
/* get the TD child nodes - taking into account text etc nodes */
anTds = [];
for ( iColumn=0, iColumns=oData.nTr.childNodes.length ; iColumn<iColumns ; iColumn++ )
{
sNodeName = oData.nTr.childNodes[iColumn].nodeName.toLowerCase();
if ( sNodeName == 'td' || sNodeName == 'th' )
{
anTds.push( oData.nTr.childNodes[iColumn] );
}
}
iCorrector = 0;
for ( iColumn=0, iColumns=oSettings.aoColumns.length ; iColumn<iColumns ; iColumn++ )
{
if ( oSettings.aoColumns[iColumn].bVisible )
{
anReturn.push( anTds[iColumn-iCorrector] );
}
else
{
anReturn.push( oData._anHidden[iColumn] );
iCorrector++;
}
}
}
}
return anReturn;
}
|
javascript
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.