_id
stringlengths 2
6
| title
stringlengths 0
58
| partition
stringclasses 3
values | text
stringlengths 52
373k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q1700
|
resolveConfig
|
train
|
function resolveConfig(conf, version = '') {
conf['siteroot'] = conf.baseurl || '/';
if (version) {
conf['baseurl'] = path.join(conf.siteroot, version);
}
for (let key in conf) {
if (CONFIG_VAR_REGEX.test(conf[key])) {
conf[key] = resolve(conf[key], conf, [key]);
}
}
return conf;
}
|
javascript
|
{
"resource": ""
}
|
q1701
|
resolve
|
train
|
function resolve(value, conf, ring = []) {
value.match(CONFIG_VAR_REGEX).forEach((variable) => {
const key = variable.substring(variable.lastIndexOf('${') + 2, variable.lastIndexOf('}'));
if (ring.includes(key)) {
throw `Circular dependency error: cannot resolve variable(s) ${ring}.`;
}
ring.push(key);
let resolved = conf[key];
if (!resolved) {
throw `Could not resolve ${key} - make sure this key is defined in _config.yml.`;
}
if (CONFIG_VAR_REGEX.test(resolved)) {
resolved = resolve(resolved, conf, ring);
}
value = value.replace(variable, resolved);
ring.pop();
});
return value;
}
|
javascript
|
{
"resource": ""
}
|
q1702
|
timeAndLog
|
train
|
function timeAndLog(text) {
if (active) {
var spaces = space.substring(0, currentIndentation);
console.error('TRACER TXT', meaningfulTime(), spaces, text);
}
}
|
javascript
|
{
"resource": ""
}
|
q1703
|
processModules
|
train
|
function processModules(item) {
if (item.exports && !item._traced) {
bootstrap(item, 'exports', item.filename);
item._traced = true;
}
if (item.children) {
item.children.map(processModules);
}
}
|
javascript
|
{
"resource": ""
}
|
q1704
|
bootstrap
|
train
|
function bootstrap(item, prop, path) {
if ( (path.split('node_modules').length > 2) || (path.slice(-4) == 'emit') || (item == require('util') && (prop=='format')) ) return;
if (!item.hasOwnProperty(prop) || Object.getOwnPropertyDescriptor(item, prop).get) return;
var original = item[prop];
if (allFuncs.indexOf(original) !== -1) return;
allFuncs.push(original);
if (item[prop] instanceof Function) {
infect(item, prop, path);
if (item[prop].prototype) {
bootstrap(item[prop], 'prototype', path+'.prototype');
}
for (var i in original) {
if (!original.hasOwnProperty(i) || Object.getOwnPropertyDescriptor(original, i).get) return;
item[prop][i] = original[i];
}
}
if (item[prop] instanceof Object) {
for (var i in item[prop]) {
bootstrap(item[prop], i, path+'.'+i);
}
}
return item;
}
|
javascript
|
{
"resource": ""
}
|
q1705
|
timeDiff
|
train
|
function timeDiff(newest, oldest) {
var diff = (parseFloat(newest) - parseFloat(oldest));
if (diff < 0) {
diff = ((10000 + parseFloat(newest)) - parseFloat(oldest));
}
return diff;
}
|
javascript
|
{
"resource": ""
}
|
q1706
|
meaningfulTime
|
train
|
function meaningfulTime() {
if (moduleRef) {
var parts = processRef.hrtime();
return (((parts[0]*1000)+(parts[1]/1000000))%10000).toFixed(2) + 'ms';
} else {
return performance.now().toFixed(2)+'ms';
}
}
|
javascript
|
{
"resource": ""
}
|
q1707
|
measureTracerOverhead
|
train
|
function measureTracerOverhead() {
var time1 = meaningfulTime();
var time2 = meaningfulTime();
console.error("TRACER OVERHEAD", timeDiff(time2, time1).toFixed(2)+'ms', 'per timing');
}
|
javascript
|
{
"resource": ""
}
|
q1708
|
processLogs
|
train
|
function processLogs() {
var calcs = 0;
for (var i in stats) {
stats[i].average = stats[i].totalTime / stats[i].count;
calcs += stats[i].calcs;
}
var time1 = meaningfulTime();
var time2 = meaningfulTime();
console.error("TRACER TOTAL OVERHEAD", (calcs*timeDiff(time2, time1)).toFixed(2)+'ms');
while (Object.keys(stats).length > 0) {
var biggest = 0;
var biggestPath = Object.keys(stats)[0];
for (var path in stats) {
if (stats[path].average >= biggest) {
biggestPath = path;
biggest = stats[path].average;
}
}
console.error("TRACER TOTAL",
stats[biggestPath].min.toFixed(2)+'ms',
stats[biggestPath].average.toFixed(2)+'ms',
stats[biggestPath].max.toFixed(2)+'ms',
stats[biggestPath].count,
biggestPath);
delete stats[biggestPath];
}
}
|
javascript
|
{
"resource": ""
}
|
q1709
|
debug
|
train
|
function debug(message) {
if (enplug.debug) {
arguments[0] = TAG + arguments[0];
console.log.apply(console, arguments);
}
}
|
javascript
|
{
"resource": ""
}
|
q1710
|
validateCallbacks
|
train
|
function validateCallbacks(options) {
if (options.successCallback && typeof options.successCallback !== 'function') {
throw new Error(TAG + 'Success callback must be a function.');
} else {
options.successCallback = options.successCallback || enplug.noop;
}
if (options.errorCallback && typeof options.errorCallback !== 'function') {
throw new Error(TAG + 'Error callback must be a function.');
} else {
options.errorCallback = options.errorCallback || enplug.noop;
}
}
|
javascript
|
{
"resource": ""
}
|
q1711
|
parseResponse
|
train
|
function parseResponse(event) {
try {
var response = JSON.parse(event.data);
// Check for success key to ignore messages being sent
if (response.namespace === namespace && typeof response.success === 'boolean') {
return response;
}
return false;
} catch (e) {}
return false;
}
|
javascript
|
{
"resource": ""
}
|
q1712
|
train
|
function (options) {
if (typeof options === 'object') {
// Add implementation-specific method prefix (dashboard or app)
options.name = this.prefix + '.' + options.name;
return this.transport.send(options);
} else {
throw new Error('Transport options must be an object.');
}
}
|
javascript
|
{
"resource": ""
}
|
|
q1713
|
decorateSend
|
train
|
function decorateSend(q, scope, transport) {
var original = transport.send;
transport.send = function (options) {
// Store originals
var defer = q.defer(),
onSuccess = options.successCallback || angular.noop,
onError = options.errorCallback || angular.noop;
options.successCallback = function (result) {
scope.$apply(function () {
defer.resolve(result);
onSuccess(result);
});
};
options.errorCallback = function (result) {
scope.$apply(function () {
defer.reject(result);
onError(result);
});
};
// Call the original transport method
// but use our promise as the return value
original.call(transport, options);
return defer.promise;
};
}
|
javascript
|
{
"resource": ""
}
|
q1714
|
train
|
function (hash) {
return new Promise((resolve, reject) => {
request(`${ ipfsProtocol }://${ ipfsHost }/ipfs/${hash}`, function (err, response, body) {
if (err) {
reject(err);
} else {
resolve(response);
}
});
});
}
|
javascript
|
{
"resource": ""
}
|
|
q1715
|
deleteDeploymentFolder
|
train
|
async function deleteDeploymentFolder() {
del.sync(deploymentTmpFolder, { force: true });
del.sync(deploymentFolder, { force: true });
}
|
javascript
|
{
"resource": ""
}
|
q1716
|
deploy
|
train
|
async function deploy() {
try {
await browserifyDBCP();
await uglify();
const ipfsHash = await deployToIPFS(`${ deploymentFolder}/${ browserifyName}`);
await pinToIPFS(ipfsHash);
const ipnsHash = await deployToIpns(ipfsHash);
deleteDeploymentFolder();
console.log(`\nFinished deployment`);
console.log(`IPFS: ${ ipfsHash }`);
console.log(`IPNS: ${ ipnsHash }`);
} catch (ex) {
console.error(ex);
}
}
|
javascript
|
{
"resource": ""
}
|
q1717
|
getPointDistance
|
train
|
function getPointDistance(x0, x1, y0, y1) {
return (Math.sqrt(((x1 - x0) * (x1 - x0)) + ((y1 - y0) * (y1 - y0))));
}
|
javascript
|
{
"resource": ""
}
|
q1718
|
getAngle
|
train
|
function getAngle(originX, originY, projectionX, projectionY) {
const angle = Math.atan2(projectionY - originY, projectionX - originX) * ((180) / Math.PI);
return 360 - ((angle < 0) ? (360 + angle) : angle);
}
|
javascript
|
{
"resource": ""
}
|
q1719
|
add
|
train
|
function add(className) {
if (typeof className === 'function') {
className = className.name;
}
extractBits.DIRECT_TYPES.push(className);
}
|
javascript
|
{
"resource": ""
}
|
q1720
|
applyTags
|
train
|
function applyTags(Class, addTags, fieldName, descriptor) {
var tags = (Array.isArray(addTags) && addTags || []).map(function (tag) {
return typeof tag === 'string' && Symbol.for(tag) || tag;
}).filter(function (tag) {
return (0, _typeof2.default)(tag) === 'symbol';
});
tags.forEach(function (tag) {
Class[_GQLBase.META_KEY][tag] = Class[_GQLBase.META_KEY][tag] || {};
Class[_GQLBase.META_KEY][tag][fieldName] = descriptor;
});
}
|
javascript
|
{
"resource": ""
}
|
q1721
|
csvWrapForExcel
|
train
|
function csvWrapForExcel(encoder) {
// Pipe the CSV encoder to the ucs2 converter
var converter = new Stream.Transform();
var csvStream = new Stream.PassThrough();
converter._transform = function(chunk, encoding, cb) {
this.push(new Buffer(chunk.toString(), 'ucs2'));
cb();
};
// Write the UCS2 BOM http://www.unicode.org/faq/utf_bom.html#bom1
csvStream.write(new Buffer([0xFF, 0xFE]));
return encoder.pipe(converter).pipe(csvStream);
}
|
javascript
|
{
"resource": ""
}
|
q1722
|
createJsonPreprocessor
|
train
|
function createJsonPreprocessor(logger, basePath, config) {
const log = logger.create('preprocessor.json');
const conf = config || {};
const stripPrefix = new RegExp(`^${(conf.stripPrefix || '')}`);
return function(content, file, done) {
log.debug('Processing "%s".', file.originalPath);
// Build json path file.
const jsonPath = file.originalPath
.replace(`${basePath}/`, '')
.replace(stripPrefix, '');
const template = createTemplate(conf.varName || '__json__');
// Update file path
file.path = `${file.path}.js`;
try {
const o = JSON.parse(content.trim());
done(util.format(template, jsonPath, JSON.stringify(o)));
} catch (e) {
log.error('Json representation of %s is not valid !', file.originalPath);
done('');
}
};
}
|
javascript
|
{
"resource": ""
}
|
q1723
|
createGetAlias
|
train
|
function createGetAlias(aliases) {
if (isPlainObject(aliases) && !Array.isArray(aliases)) {
aliases = Object.keys(aliases).map((key) => { // eslint-disable-line
let onlyModule = false;
let obj = aliases[key];
if (/\$$/.test(key)) {
onlyModule = true;
key = key.substr(0, key.length - 1); // eslint-disable-line
}
if (isString(obj)) {
obj = {
alias: obj,
};
}
return {
name: key,
onlyModule,
...obj,
};
});
}
return (request) => {
for (const alias of aliases) {
if ((!alias.onlyModule && request.indexOf(`${alias.name}/`) === 0) || request === alias.name) {
if (request.indexOf(`${alias.alias}/`) !== 0 && request !== alias.alias) {
return alias.alias + request.substr(alias.name.length);
}
}
}
return request;
};
}
|
javascript
|
{
"resource": ""
}
|
q1724
|
setChecklist
|
train
|
function setChecklist(Class, item) {
var value = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
var checklist = getChecklist(Class);
if (checklist) {
// $FlowFixMe
checklist[item] = value;
}
}
|
javascript
|
{
"resource": ""
}
|
q1725
|
hasChecklist
|
train
|
function hasChecklist(Class) {
var checklist = getChecklist(Class);
for (var _len2 = arguments.length, items = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
items[_key2 - 1] = arguments[_key2];
}
if (checklist && items.length) {
for (var _i2 = 0; _i2 < items.length; _i2++) {
var item = items[_i2];
if (!checklist[item]) {
return false;
}
}
return true;
}
return checklist;
}
|
javascript
|
{
"resource": ""
}
|
q1726
|
newChecklist
|
train
|
function newChecklist(Class) {
if (Class) {
var _keys, _complete, _Class$META_KEY$CHECK, _mutatorMap;
// $FlowFixMe
Class[_GQLBase.META_KEY][CHECKLIST] = (_Class$META_KEY$CHECK = {}, (0, _defineProperty2.default)(_Class$META_KEY$CHECK, CHECK_SCHEMA, false), (0, _defineProperty2.default)(_Class$META_KEY$CHECK, CHECK_RESOLVERS, false), (0, _defineProperty2.default)(_Class$META_KEY$CHECK, CHECK_API_DOCS, false), _keys = "keys", _mutatorMap = {}, _mutatorMap[_keys] = _mutatorMap[_keys] || {}, _mutatorMap[_keys].get = function () {
return [CHECK_SCHEMA, CHECK_RESOLVERS, CHECK_API_DOCS];
}, _complete = "complete", _mutatorMap[_complete] = _mutatorMap[_complete] || {}, _mutatorMap[_complete].get = function () {
var _this = this;
return this.keys.reduce(function (p, c, i, a) {
if (!p || !_this[c]) {
return false;
}
}, true);
}, (0, _defineEnumerableProperties2.default)(_Class$META_KEY$CHECK, _mutatorMap), _Class$META_KEY$CHECK);
} else {
throw new Error((0, _neTagFns.customDedent)({
dropLowest: true
})(_templateObject()));
}
}
|
javascript
|
{
"resource": ""
}
|
q1727
|
validateTemplate
|
train
|
function validateTemplate(template) {
var hide = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
var results = new ValidationResults();
var indent = function indent(string) {
var count = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 4;
var space = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : ' ';
return string.split('\n').map(function (s) {
return s.trim().replace(/(^)/gm, "$1".concat(space.repeat(count)));
}).join('\n');
};
if (typeof template.name === 'undefined') {
results.errors.push(new Error((0, _neTagFns.customDedent)({
dropLowest: true
})(_templateObject2())));
}
if (!(0, _neTypes.extendsFrom)(template.name, String)) {
results.errors.push(new Error((0, _neTagFns.customDedent)({
dropLowest: true
})(_templateObject3())));
}
if (typeof template.schema === 'undefined') {
results.errors.push(new Error((0, _neTagFns.customDedent)({
dropLowest: true
})(_templateObject4())));
}
if (!(0, _neTypes.extendsFrom)(template.schema, String)) {
results.errors.push(new Error((0, _neTagFns.customDedent)({
dropLowest: true
})(_templateObject5())));
}
if (!(0, _neTypes.extendsFrom)(template.resolvers, Object) // Supports 95% of objects
|| (0, _typeof2.default)(template.resolvers) !== 'object' // Supports Object.create(null)
) {
results.errors.push(new Error((0, _neTagFns.customDedent)({
dropLowest: true
})(_templateObject6())));
}
if (typeof template.docs === 'undefined') {
results.errors.push(new Error((0, _neTagFns.customDedent)({
dropLowest: true
})(_templateObject7())));
}
if (!(0, _neTypes.extendsFrom)(template.docs, Object) // Supports 95% of objects
|| (0, _typeof2.default)(template.docs) !== 'object' // Supports Object.create(null)
) {
var dr = '\x1b[31m',
br = '\x1b[91m';
var b1 = '\x1b[1m',
b0 = '\x1b[22m';
var bb = '\x1b[90m';
var dg = '\x1b[37m',
bg = '\x1b[97m';
var a0 = '\x1b[0m';
var gr = '\x1b[32m',
bgr = '\x1b[92m';
results.errors.push(new Error((0, _neTagFns.customDedent)({
dropLowest: true
})(_templateObject8(), bb, dg, b1, b0, gr, dg, b1, b0, b1, b0, gr, dg, gr, dg, gr, dg, b1, b0, gr, dg, b1, b0, gr, dg)));
}
if (!results.valid) {
var errorStrings = [];
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = results.errors[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var _error = _step.value;
var message = _error.message,
stack = _error.stack;
stack = stack.trim().split('\n').splice(message.split('\n').length).map(function (s) {
return s.trim();
}).join('\n');
message = message.replace(/(Error:\s)/, '$1\n').trim();
errorStrings.push("\x1B[31;1m".concat(message, "\x1B[0m\n") + indent(stack));
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return != null) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
var error = new Error((0, _neTagFns.customDedent)({
dropLowest: true
})(_templateObject9()).replace(/@template/, indent(_i(template))).replace(/@errors/, errorStrings.join('\n\n')));
error.stack = error.message;
error.message = '';
if (!hide) throw error;
}
return results;
}
|
javascript
|
{
"resource": ""
}
|
q1728
|
train
|
function(hook, context){
var hs = $('#heading-selection');
hs.on('change', function(){
var value = $(this).val();
var intValue = parseInt(value,10);
if(!_.isNaN(intValue)){
context.ace.callWithAce(function(ace){
ace.ace_doInsertHeading(intValue);
},'insertheading' , true);
hs.val("dummy");
}
})
}
|
javascript
|
{
"resource": ""
}
|
|
q1729
|
aceInitialized
|
train
|
function aceInitialized(hook, context){
var editorInfo = context.editorInfo;
editorInfo.ace_doInsertHeading = _(doInsertHeading).bind(context);
}
|
javascript
|
{
"resource": ""
}
|
q1730
|
argMapper
|
train
|
function argMapper(arg, index, array) {
var isError = (0, _neTypes.typeOf)(arg) === Error.name;
var showStack = /\bSTACK\b/i.test(process.env.LATTICE_ERRORS || ''); // $FlowFixMe
return !isError ? arg : showStack ? arg : arg.message;
}
|
javascript
|
{
"resource": ""
}
|
q1731
|
failFast
|
train
|
function failFast(logLevel, lessThan) {
var ll = LatticeLogs;
if (logLevel) {
var compareTo = lessThan || process.env.LATTICE_LOGLEVEL || ll.ERROR;
if (!ll.equalOrBelow(logLevel, compareTo)) return true;
}
return /\b(NONE|OFF|NO|0)\b/i.test(process.env.LATTICE_ERRORS || '');
}
|
javascript
|
{
"resource": ""
}
|
q1732
|
log
|
train
|
function log() {
var _console;
if (LatticeLogs.failFast(LatticeLogs.LOG)) return;
for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
args[_key3] = arguments[_key3];
}
(_console = console).log.apply(_console, (0, _toConsumableArray2.default)(args.map(LatticeLogs.argMapper)));
}
|
javascript
|
{
"resource": ""
}
|
q1733
|
warn
|
train
|
function warn() {
var _console2;
if (LatticeLogs.failFast(LatticeLogs.WARN)) return;
for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
args[_key4] = arguments[_key4];
}
(_console2 = console).warn.apply(_console2, (0, _toConsumableArray2.default)(args.map(LatticeLogs.argMapper)));
}
|
javascript
|
{
"resource": ""
}
|
q1734
|
error
|
train
|
function error() {
var _console3;
if (LatticeLogs.failFast(LatticeLogs.ERROR)) return;
for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
args[_key5] = arguments[_key5];
}
(_console3 = console).error.apply(_console3, (0, _toConsumableArray2.default)(args.map(LatticeLogs.argMapper)));
}
|
javascript
|
{
"resource": ""
}
|
q1735
|
info
|
train
|
function info() {
var _console4;
if (LatticeLogs.failFast(LatticeLogs.INFO)) return;
for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
args[_key6] = arguments[_key6];
}
(_console4 = console).info.apply(_console4, (0, _toConsumableArray2.default)(args.map(LatticeLogs.argMapper)));
}
|
javascript
|
{
"resource": ""
}
|
q1736
|
trace
|
train
|
function trace() {
var _console5;
if (LatticeLogs.failFast(LatticeLogs.TRACE)) return;
for (var _len7 = arguments.length, args = new Array(_len7), _key7 = 0; _key7 < _len7; _key7++) {
args[_key7] = arguments[_key7];
}
(_console5 = console).trace.apply(_console5, (0, _toConsumableArray2.default)(args.map(LatticeLogs.argMapper)));
}
|
javascript
|
{
"resource": ""
}
|
q1737
|
notDefined
|
train
|
function notDefined(keyToTest, keySupplied, instance) {
return new RegExp("^" + keyToTest + "$").test(keySupplied.toString()) && !instance.hasOwnProperty(keyToTest);
}
|
javascript
|
{
"resource": ""
}
|
q1738
|
getProp
|
train
|
function getProp(propName) {
var bindGetters = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
var bindTo = arguments.length > 2 ? arguments[2] : undefined;
// $FlowFixMe
var proto = Object.getPrototypeOf(this);
var descriptor = Object.getOwnPropertyDescriptor(proto, propName);
var result;
if (!descriptor) {
return null;
}
if (descriptor) {
if (descriptor.initializer || descriptor.get) {
var what = descriptor.initializer || descriptor.get;
if (bindGetters) {
result = what.bind(bindTo || this);
} else {
result = what;
}
} else if (descriptor.value) {
result = descriptor.value;
}
}
return result;
}
|
javascript
|
{
"resource": ""
}
|
q1739
|
IDLFilePath
|
train
|
function IDLFilePath(path) {
var extension = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '.graphql';
return Symbol.for("Path ".concat(path, " Extension ").concat(extension));
}
|
javascript
|
{
"resource": ""
}
|
q1740
|
nodeToString
|
train
|
function nodeToString(node) {
switch (node.type) {
case ("BinaryExpression"): {
return nodeToString(node.left) + node.operator.toString() + nodeToString(node.right);
}
case ("CallExpression"): {
var args = node.arguments.map(function(arg) {
return nodeToString(arg);
}).toString();
return nodeToString(node.callee) + "(" + args + ")";
}
case ("ConditionalExpression"): {
return nodeToString(node.test) + "?" + nodeToString(node.consequent) + ":" + nodeToString(node.alternate);
}
case ("Identifier"): {
return node.name.toString();
}
case ("Literal"): {
return node.value.toString();
}
case ("MemberExpression"): {
return nodeToString(node.object) + "[" + nodeToString(node.property) + "]";
}
case ("TemplateElement"): {
return node.value.raw.toString();
}
case ("TemplateLiteral"): {
// interleave quasis with expressions
var s = [];
node.quasis.forEach(function(quasi, i) {
if (quasi.value.raw) {
s.push(nodeToString(quasi));
}
var expression = node.expressions[i];
if (expression) {
s.push(nodeToString(expression));
}
});
return s.join("");
}
default: {
// Silently ignore Nodes with types we don't handle
return "";
}
}
}
|
javascript
|
{
"resource": ""
}
|
q1741
|
train
|
function(positions) {
var xs = [], ys = [], zs = [];
var xi = {}, yi = {}, zi = {};
for (var i=0; i<positions.length; i++) {
var p = positions[i];
var x = p[0], y = p[1], z = p[2];
// Split the positions array into arrays of unique component values.
//
// Why go through the trouble of using a uniqueness hash table vs
// sort and uniq:
//
// Suppose you've got a million positions in a 100x100x100 grid.
//
// Using a uniqueness hash table, you're doing 1M array reads,
// 3M hash table lookups from 100-element hashes, 300 hash table inserts, then
// sorting three 100-element arrays and iterating over them.
// Roughly, 1M + 3M * ln(100) + 300 * ln(100/2) + 3 * 100 * ln(100) + 3 * 100 =
// 1M + 13.8M + 0.0012M + 0.0014M + 0.0003M
// =~ 15M
//
// Sort and uniq solution would do 1M array reads, 3M array inserts,
// sort three 1M-element arrays and iterate over them.
// Roughly, 1M + 3M + 3 * 1M * ln(1M) + 3 * 1M =
// 1M + 3M + 41.4M + 3M
// =~ 48.4M
//
// Guessing that a hard-coded sort & uniq would be faster due to not having
// to run a hashing function on everything. More memory usage though
// (bunch of small hash tables vs. duplicating the input array.)
//
// In JS-land, who knows. Maybe xi[x] casts x to string and destroys perf,
// maybe numeric keys get special-cased, maybe the object lookups run at near O(1)-speeds.
// Maybe the sorting comparison function is expensive to call, maybe it gets inlined or special-cased.
//
// ... You're probably not going to call this with more than 10k positions anyhow, so this is very academic.
//
if (!xi[x]) {
xs.push(x);
xi[x] = true;
}
if (!yi[y]) {
ys.push(y);
yi[y] = true;
}
if (!zi[z]) {
zs.push(z);
zi[z] = true;
}
}
var xSep = findMinSeparation(xs);
var ySep = findMinSeparation(ys);
var zSep = findMinSeparation(zs);
var minSeparation = Math.min(xSep, ySep, zSep);
if (!isFinite(minSeparation)) {
return 1;
}
return minSeparation;
}
|
javascript
|
{
"resource": ""
}
|
|
q1742
|
encryptAndHash
|
train
|
function encryptAndHash (state, ciphertext, plaintext) {
assert(state.byteLength === STATELEN)
assert(ciphertext.byteLength != null)
assert(plaintext.byteLength != null)
var cstate = state.subarray(CIPHER_BEGIN, CIPHER_END)
var h = state.subarray(HASH_BEGIN, HASH_END)
cipherState.encryptWithAd(cstate, ciphertext, h, plaintext)
encryptAndHash.bytesRead = cipherState.encryptWithAd.bytesRead
encryptAndHash.bytesWritten = cipherState.encryptWithAd.bytesWritten
mixHash(state, ciphertext.subarray(0, encryptAndHash.bytesWritten))
}
|
javascript
|
{
"resource": ""
}
|
q1743
|
mapStateToProps
|
train
|
function mapStateToProps(state) {
return {
clicker: state.clicker,
repoUser: state.repoUser,
repositories: state.repositories,
errors: state.errors
};
}
|
javascript
|
{
"resource": ""
}
|
q1744
|
computeRateBetweenSubunitAmounts
|
train
|
function computeRateBetweenSubunitAmounts(fromCurrency, fromAmount, toCurrency, toAmount) {
/*
* If currencies are equal, rate is 1
*/
if (fromCurrency === toCurrency) {
return 1;
}
/*
* If toAmount is 0, we don't want to divide by zero.
* In this case, return NaN
*/
if (toAmount === 0) {
return NaN;
}
/*
* Convert both amounts to main units
*/
const fromAmountMainUnit = fromSmallestSubunit(fromAmount, fromCurrency);
const toAmountMainUnit = fromSmallestSubunit(toAmount, toCurrency);
/*
* Compute and return rate
*/
return fromAmountMainUnit / toAmountMainUnit;
}
|
javascript
|
{
"resource": ""
}
|
q1745
|
train
|
function(context, keys){
// If nothing can be found with the keys we are looking for, save the
// first possible match. This is where we will write to.
if(firstSearchedContext === undefined && !(context instanceof LetContext)) {
firstSearchedContext = context;
}
// If we have multiple keys ...
if(keys.length > 1) {
// see if we can find the parent ...
var parentKeys = keys.slice(0, keys.length-1);
var parent = stacheKey.read(context, parentKeys, options).value;
// If there is a parent, see if it has the last key
if( parent != null && canReflect.hasKey(parent, keys[keys.length-1].key ) ) {
return {
parent: parent,
parentHasKey: true,
value: undefined
};
} else {
return {};
}
}
// If we have only one key, try to find a context with this key
else if(keys.length === 1) {
if( canReflect.hasKey(context, keys[0].key ) ) {
return {
parent: context,
parentHasKey: true,
value: undefined
};
} else {
return {};
}
}
// If we have no keys, we are reading `this`.
else {
return {
value: context
};
}
}
|
javascript
|
{
"resource": ""
}
|
|
q1746
|
train
|
function() {
var top;
this.getScope(function(scope) {
if (scope._meta.viewModel) {
top = scope;
}
// walk entire scope tree
return false;
});
return top && top._context;
}
|
javascript
|
{
"resource": ""
}
|
|
q1747
|
toArray
|
train
|
function toArray(x, delimiter)
{
if ( x instanceof Array )
{
return x;
}
if ( isString( x ) )
{
return x.split( delimiter );
}
if ( isValue( x ) )
{
return [ x ];
}
return [];
}
|
javascript
|
{
"resource": ""
}
|
q1748
|
indexOf
|
train
|
function indexOf(arr, x, comparator)
{
var cmp = comparator || equalsStrict;
for (var i = 0, n = arr.length; i < n; i++)
{
if ( cmp( arr[i], x ) )
{
return i;
}
}
return false;
}
|
javascript
|
{
"resource": ""
}
|
q1749
|
isRekord
|
train
|
function isRekord(x)
{
return !!(x && x.Database && isFunction( x ) && x.prototype instanceof Model);
}
|
javascript
|
{
"resource": ""
}
|
q1750
|
createComparator
|
train
|
function createComparator(comparator, nullsFirst)
{
if ( isFunction( comparator ) )
{
return comparator;
}
else if ( isString( comparator ) )
{
if ( comparator in Comparators )
{
return Comparators[ comparator ];
}
if ( comparator.charAt(0) === '-' )
{
var parsed = createComparator( comparator.substring( 1 ), !nullsFirst );
return function compareObjectsReversed(a, b)
{
return -parsed( a, b );
};
}
else if ( isFormatInput( comparator ) )
{
var formatter = createFormatter( comparator );
return function compareFormatted(a, b)
{
var af = formatter( a );
var bf = formatter( b );
return af.localeCompare( bf );
};
}
else if ( isParseInput( comparator ) )
{
var parser = createParser( comparator );
return function compareExpression(a, b)
{
var ap = parser( a );
var bp = parser( b );
return compare( ap, bp, nullsFirst );
};
}
else
{
return function compareObjects(a, b)
{
var av = isValue( a ) ? a[ comparator ] : a;
var bv = isValue( b ) ? b[ comparator ] : b;
return compare( av, bv, nullsFirst );
};
}
}
else if ( isArray( comparator ) )
{
var parsedChain = [];
for (var i = 0; i < comparator.length; i++)
{
parsedChain[ i ] = createComparator( comparator[ i ], nullsFirst );
}
return function compareObjectsCascade(a, b)
{
var d = 0;
for (var i = 0; i < parsedChain.length && d === 0; i++)
{
d = parsedChain[ i ]( a, b );
}
return d;
};
}
return null;
}
|
javascript
|
{
"resource": ""
}
|
q1751
|
on
|
train
|
function on(events, callback, context)
{
return onListeners( this, events, callback, context, EventNode.Types.Persistent );
}
|
javascript
|
{
"resource": ""
}
|
q1752
|
once
|
train
|
function once(events, callback, context)
{
return onListeners( this, events, callback, context, EventNode.Types.Once );
}
|
javascript
|
{
"resource": ""
}
|
q1753
|
offListeners
|
train
|
function offListeners(listeners, event, callback)
{
if (listeners && event in listeners)
{
var eventListeners = listeners[ event ];
var next, node = eventListeners.next;
while (node !== eventListeners)
{
next = node.next;
if (node.callback === callback)
{
node.remove();
}
node = next;
}
}
}
|
javascript
|
{
"resource": ""
}
|
q1754
|
off
|
train
|
function off(eventsInput, callback)
{
// Remove ALL listeners
if ( !isDefined( eventsInput ) )
{
deleteProperty( this, '$$on' );
}
else
{
var events = toArray( eventsInput, ' ' );
// Remove listeners for given events
if ( !isFunction( callback ) )
{
for (var i = 0; i < events.length; i++)
{
deleteProperty( this.$$on, events[i] );
}
}
// Remove specific listener
else
{
for (var i = 0; i < events.length; i++)
{
offListeners( this.$$on, events[i], callback );
}
}
}
return this;
}
|
javascript
|
{
"resource": ""
}
|
q1755
|
triggerListeners
|
train
|
function triggerListeners(listeners, event, args)
{
if (listeners && event in listeners)
{
var eventListeners = listeners[ event ];
var triggerGroup = ++triggerId;
var next, node = eventListeners.next;
while (node !== eventListeners)
{
next = node.next;
node.trigger( triggerGroup, args, false );
node = next;
}
node = eventListeners.next;
while (node !== eventListeners)
{
next = node.next;
node.trigger( triggerGroup, args, true );
node = next;
}
}
}
|
javascript
|
{
"resource": ""
}
|
q1756
|
trigger
|
train
|
function trigger(eventsInput, args)
{
try
{
var events = toArray( eventsInput, ' ' );
for (var i = 0; i < events.length; i++)
{
triggerListeners( this.$$on, events[ i ], args );
}
}
catch (ex)
{
Rekord.trigger( Rekord.Events.Error, [ex] );
}
return this;
}
|
javascript
|
{
"resource": ""
}
|
q1757
|
merge
|
train
|
function merge(dst, src, ignoreMap)
{
if (isObject( dst ) && isObject( src ))
{
for (var prop in src)
{
if (!ignoreMap || !ignoreMap[ prop ])
{
var adding = src[ prop ];
if (prop in dst)
{
var existing = dst[ prop ];
if (isArray( existing ))
{
if (isArray( adding ))
{
existing.push.apply( existing, adding );
}
else
{
existing.push( adding );
}
}
else if (isObject( existing ))
{
merge( existing, adding, ignoreMap );
}
else
{
dst[ prop ] = copy( adding, true );
}
}
else
{
dst[ prop ] = copy( adding, true );
}
}
}
}
return dst;
}
|
javascript
|
{
"resource": ""
}
|
q1758
|
propsMatch
|
train
|
function propsMatch(test, testFields, expected, expectedFields, equals)
{
var equality = equals || Rekord.equals;
if ( isString( testFields ) ) // && isString( expectedFields )
{
return equality( test[ testFields ], expected[ expectedFields ] );
}
else // if ( isArray( testFields ) && isArray( expectedFields ) )
{
for (var i = 0; i < testFields.length; i++)
{
var testProp = testFields[ i ];
var expectedProp = expectedFields[ i ];
if ( !equality( test[ testProp ], expected[ expectedProp ] ) )
{
return false;
}
}
return true;
}
return false;
}
|
javascript
|
{
"resource": ""
}
|
q1759
|
hasFields
|
train
|
function hasFields(model, fields, exists)
{
if ( isArray( fields ) )
{
for (var i = 0; i < fields.length; i++)
{
if ( !exists( model[ fields[ i ] ] ) )
{
return false;
}
}
return true;
}
else // isString( fields )
{
return exists( model[ fields ] );
}
}
|
javascript
|
{
"resource": ""
}
|
q1760
|
createPropertyResolver
|
train
|
function createPropertyResolver(properties)
{
if ( isFunction( properties ) )
{
return properties;
}
else if ( isString( properties ) )
{
if ( properties in PropertyResolvers )
{
return PropertyResolvers[ properties ];
}
if ( isFormatInput( properties ) )
{
return createFormatter( properties );
}
else if ( isParseInput( properties ) )
{
return createParser( properties );
}
else
{
return function resolveProperty(model)
{
return model ? model[ properties ] : undefined;
};
}
}
else if ( isArray( properties ) )
{
return function resolveProperties(model)
{
return pull( model, properties );
};
}
else if ( isObject( properties ) )
{
var propsArray = [];
var propsResolver = [];
for (var prop in properties)
{
propsArray.push( prop );
propsResolver.push( createPropertyResolver( properties[ prop ] ) );
}
return function resolvePropertyObject(model)
{
var resolved = {};
for (var i = 0; i < propsArray.length; i++)
{
var prop = propsArray[ i ];
resolved[ prop ] = propsResolver[ i ]( model[ prop ] );
}
return resolved;
};
}
else
{
return function resolveNone(model)
{
return model;
};
}
}
|
javascript
|
{
"resource": ""
}
|
q1761
|
createWhere
|
train
|
function createWhere(properties, value, equals)
{
var equality = equals || equalsStrict;
if ( isFunction( properties ) )
{
return properties;
}
else if ( isArray( properties ) )
{
var parsed = [];
for (var i = 0; i < properties.length; i++)
{
var where = properties[ i ];
parsed.push( isArray( where ) ? createWhere.apply( this, where ) : createWhere( where ) );
}
return function whereMultiple(model)
{
for (var i = 0; i < parsed.length; i++)
{
if ( !parsed[ i ]( model ) )
{
return false;
}
}
return true;
};
}
else if ( isObject( properties ) )
{
var props = [];
for (var prop in properties)
{
props.push({
tester: exprEqualsTester( properties[ prop ], equality ),
resolver: createPropertyResolver( prop )
});
}
return function whereEqualsObject(model)
{
for (var i = 0; i < props.length; i++)
{
var prop = props[ i ];
if ( !prop.tester( prop.resolver( model ) ) )
{
return false;
}
}
return true;
};
}
else if ( isString( properties ) )
{
if ( properties in Wheres )
{
return Wheres[ properties ];
}
var resolver = createPropertyResolver( properties );
if ( isValue( value ) )
{
var tester = exprEqualsTester( value, equality );
return function whereEqualsValue(model)
{
return tester( resolver( model ) );
};
}
else
{
return function whereHasValue(model)
{
return isValue( resolver( model ) );
};
}
}
else
{
return function whereAll(model)
{
return true;
};
}
}
|
javascript
|
{
"resource": ""
}
|
q1762
|
Rekord
|
train
|
function Rekord(options)
{
var promise = Rekord.get( options.name );
if ( promise.isComplete() )
{
return promise.results[0];
}
Rekord.trigger( Rekord.Events.Options, [options] );
var database = new Database( options );
var model = Class.dynamic(
Model,
new Model( database ),
database.className,
'(props, remoteData) { this.$init( props, remoteData ) }'
);
database.Model = model;
model.Database = database;
Rekord.classes[ database.name ] = model;
Rekord.trigger( Rekord.Events.Plugins, [model, database, options] );
if ( Rekord.autoload )
{
database.loadBegin(function onLoadFinish(success)
{
if ( success )
{
database.loadFinish();
}
});
}
else
{
Rekord.unloaded.push( database );
}
Rekord.get( database.name ).resolve( model );
Rekord.get( database.className ).resolve( model );
Rekord.debug( Rekord.Debugs.CREATION, database, options );
return model;
}
|
javascript
|
{
"resource": ""
}
|
q1763
|
train
|
function(saving)
{
if ( !isObject( saving ) )
{
return false;
}
for (var prop in saving)
{
if ( !this.ignoredFields[ prop ] )
{
return true;
}
}
return false;
}
|
javascript
|
{
"resource": ""
}
|
|
q1764
|
train
|
function(input, callback, context, remoteData)
{
var db = this;
var promise = new Promise();
promise.success( callback, context || db );
function checkModel()
{
var result = db.parseModel( input, remoteData );
if ( result !== false && !promise.isComplete() && db.initialized )
{
var remoteLoaded = db.remoteLoaded || !db.hasLoad( Load.All );
var missingModel = (result === null || !result.$isSaved());
var lazyLoad = db.hasLoad( Load.Lazy );
if ( lazyLoad && remoteLoaded && missingModel )
{
if ( !result )
{
result = db.keyHandler.buildObjectFromKey( db.keyHandler.buildKeyFromInput( input ) );
}
result.$once( Model.Events.RemoteGets, function()
{
if ( !promise.isComplete() )
{
if ( isObject( input ) )
{
result.$set( input );
}
promise.resolve( result.$isSaved() ? result : null );
}
});
result.$refresh( Cascade.All, db.fetchOptions );
}
else
{
promise.resolve( result );
}
}
return promise.isComplete() ? false : true;
}
if ( checkModel() )
{
db.ready( checkModel, db, true );
}
return promise;
}
|
javascript
|
{
"resource": ""
}
|
|
q1765
|
train
|
function(revision)
{
if ( isFunction( revision ) )
{
this.revisionFunction = revision;
}
else if ( isString( revision ) )
{
this.revisionFunction = function(a, b)
{
var ar = isObject( a ) && revision in a ? a[ revision ] : undefined;
var br = isObject( b ) && revision in b ? b[ revision ] : undefined;
return ar === undefined || br === undefined ? false : compare( ar, br ) > 0;
};
}
else
{
this.revisionFunction = function(a, b)
{
return false;
};
}
}
|
javascript
|
{
"resource": ""
}
|
|
q1766
|
train
|
function(key)
{
var db = this;
var model = db.all[ key ];
if ( db.cache === Cache.All )
{
return db.destroyLocalCachedModel( model, key );
}
else
{
return db.destroyLocalUncachedModel( model, key );
}
}
|
javascript
|
{
"resource": ""
}
|
|
q1767
|
train
|
function(callback, context)
{
var db = this;
var promise = new Promise();
var success = this.handleRefreshSuccess( promise );
var failure = this.handleRefreshFailure( promise );
promise.complete( callback, context || db );
batchExecute(function()
{
db.executeRefresh( success, failure );
});
return promise;
}
|
javascript
|
{
"resource": ""
}
|
|
q1768
|
train
|
function(model, cascade, options)
{
var db = this;
if ( model.$isDeleted() )
{
Rekord.debug( Rekord.Debugs.SAVE_DELETED, db, model );
return;
}
var key = model.$key();
var existing = db.models.has( key );
if ( existing )
{
db.trigger( Database.Events.ModelUpdated, [model] );
model.$trigger( Model.Events.UpdateAndSave );
}
else
{
db.saveReference( model, key );
db.trigger( Database.Events.ModelAdded, [model] );
db.updated();
model.$trigger( Model.Events.CreateAndSave );
}
model.$addOperation( SaveLocal, cascade, options );
}
|
javascript
|
{
"resource": ""
}
|
|
q1769
|
train
|
function(model, cascade, options)
{
var db = this;
// If we have it in the models, remove it!
this.removeFromModels( model );
// If we're offline and we have a pending save - cancel the pending save.
if ( model.$status === Model.Status.SavePending )
{
Rekord.debug( Rekord.Debugs.REMOVE_CANCEL_SAVE, db, model );
}
model.$status = Model.Status.RemovePending;
model.$addOperation( RemoveLocal, cascade, options );
}
|
javascript
|
{
"resource": ""
}
|
|
q1770
|
train
|
function(key, value)
{
if ( key in this.indices )
{
this.values[ this.indices[ key ] ] = value;
}
else
{
this.indices[ key ] = this.values.length;
AP.push.call( this.values, value );
AP.push.call( this.keys, key );
}
return this;
}
|
javascript
|
{
"resource": ""
}
|
|
q1771
|
train
|
function(index)
{
var key = this.keys[ index ];
var lastValue = AP.pop.apply( this.values );
var lastKey = AP.pop.apply( this.keys );
if ( index < this.values.length )
{
this.values[ index ] = lastValue;
this.keys[ index ] = lastKey;
this.indices[ lastKey ] = index;
}
delete this.indices[ key ];
return this;
}
|
javascript
|
{
"resource": ""
}
|
|
q1772
|
train
|
function(callback, dest)
{
var out = dest || new Map();
var n = this.size();
var values = this.values;
var keys = this.keys;
for (var i = 0; i < n; i++)
{
var v = values[ i ];
var k = keys[ i ];
if ( callback( v, k ) )
{
out.put( k, v );
}
}
return out;
}
|
javascript
|
{
"resource": ""
}
|
|
q1773
|
train
|
function(comparator)
{
var map = this;
// Sort this partition!
function partition(left, right)
{
var pivot = map.values[ Math.floor((right + left) / 2) ];
var i = left;
var j = right;
while (i <= j)
{
while (comparator( map.values[i], pivot ) < 0)
{
i++;
}
while (comparator( map.values[j], pivot ) > 0)
{
j--;
}
if (i <= j)
{
swap( map.values, i, j );
swap( map.keys, i, j );
i++;
j--;
}
}
return i;
}
// Quicksort
function qsort(left, right)
{
var index = partition( left, right );
if (left < index - 1)
{
qsort( left, index - 1 );
}
if (index < right)
{
qsort( index, right );
}
}
var right = this.size() - 1;
// Are there elements to sort?
if ( right > 0 )
{
qsort( 0, right );
this.rebuildIndex();
}
return this;
}
|
javascript
|
{
"resource": ""
}
|
|
q1774
|
partition
|
train
|
function partition(left, right)
{
var pivot = map.values[ Math.floor((right + left) / 2) ];
var i = left;
var j = right;
while (i <= j)
{
while (comparator( map.values[i], pivot ) < 0)
{
i++;
}
while (comparator( map.values[j], pivot ) > 0)
{
j--;
}
if (i <= j)
{
swap( map.values, i, j );
swap( map.keys, i, j );
i++;
j--;
}
}
return i;
}
|
javascript
|
{
"resource": ""
}
|
q1775
|
train
|
function()
{
this.indices = {};
for (var i = 0, l = this.keys.length; i < l; i++)
{
this.indices[ this.keys[ i ] ] = i;
}
return this;
}
|
javascript
|
{
"resource": ""
}
|
|
q1776
|
train
|
function(out)
{
var target = out || {};
var keys = this.keys;
var values = this.values;
for (var i = 0; i < keys.length; i++)
{
target[ keys[ i ] ] = values[ i ];
}
return target;
}
|
javascript
|
{
"resource": ""
}
|
|
q1777
|
train
|
function(comparator, nullsFirst)
{
var cmp = comparator ? createComparator( comparator, nullsFirst ) : this.comparator;
return isSorted( cmp, this );
}
|
javascript
|
{
"resource": ""
}
|
|
q1778
|
train
|
function(comparator, nullsFirst, ignorePrimitive)
{
var cmp = comparator ? createComparator( comparator, nullsFirst ) : this.comparator;
if ( !isSorted( cmp, this ) || ( !ignorePrimitive && !cmp && isPrimitiveArray( this ) ) )
{
AP.sort.call( this, cmp );
this.trigger( Collection.Events.Sort, [this] );
}
return this;
}
|
javascript
|
{
"resource": ""
}
|
|
q1779
|
train
|
function(values)
{
this.length = 0;
if ( isArray( values ) )
{
AP.push.apply( this, values );
}
else if ( isValue( values ) )
{
AP.push.call( this, values );
}
this.trigger( Collection.Events.Reset, [this] );
this.sort( undefined, undefined, true );
return this;
}
|
javascript
|
{
"resource": ""
}
|
|
q1780
|
train
|
function(collection, out, equals)
{
var target = out || this.cloneEmpty();
var equality = equals || equalsStrict;
for (var i = 0; i < this.length; i++)
{
var a = this[ i ];
var exists = false;
for (var j = 0; j < collection.length && !exists; j++)
{
exists = equality( a, collection[ j ] );
}
if (!exists)
{
target.push( a );
}
}
return target;
}
|
javascript
|
{
"resource": ""
}
|
|
q1781
|
train
|
function()
{
var values = arguments;
AP.unshift.apply( this, values );
this.trigger( Collection.Events.Adds, [this, AP.slice.apply(values), 0] );
this.sort( undefined, undefined, true );
return this.length;
}
|
javascript
|
{
"resource": ""
}
|
|
q1782
|
train
|
function(values, delaySort)
{
if ( isArray( values ) && values.length )
{
var i = this.length;
AP.push.apply( this, values );
this.trigger( Collection.Events.Adds, [this, values, i] );
if ( !delaySort )
{
this.sort( undefined, undefined, true );
}
}
return this;
}
|
javascript
|
{
"resource": ""
}
|
|
q1783
|
train
|
function(i, value, delaySort)
{
AP.splice.call( this, i, 0, value );
this.trigger( Collection.Events.Add, [this, value, i] );
if ( !delaySort )
{
this.sort( undefined, undefined, true );
}
return this;
}
|
javascript
|
{
"resource": ""
}
|
|
q1784
|
train
|
function(delaySort)
{
var removed = AP.pop.apply( this );
var i = this.length;
this.trigger( Collection.Events.Remove, [this, removed, i] );
if ( !delaySort )
{
this.sort( undefined, undefined, true );
}
return removed;
}
|
javascript
|
{
"resource": ""
}
|
|
q1785
|
train
|
function(delaySort)
{
var removed = AP.shift.apply( this );
this.trigger( Collection.Events.Remove, [this, removed, 0] );
if ( !delaySort )
{
this.sort( undefined, undefined, true );
}
return removed;
}
|
javascript
|
{
"resource": ""
}
|
|
q1786
|
train
|
function(i, delaySort)
{
var removing;
if (i >= 0 && i < this.length)
{
removing = this[ i ];
AP.splice.call( this, i, 1 );
this.trigger( Collection.Events.Remove, [this, removing, i] );
if ( !delaySort )
{
this.sort( undefined, undefined, true );
}
}
return removing;
}
|
javascript
|
{
"resource": ""
}
|
|
q1787
|
train
|
function(value, delaySort, equals)
{
var i = this.indexOf( value, equals );
var element = this[ i ];
if ( i !== -1 )
{
this.removeAt( i, delaySort );
}
return element;
}
|
javascript
|
{
"resource": ""
}
|
|
q1788
|
train
|
function(values, delaySort, equals)
{
var removed = [];
var removedIndices = [];
if ( isArray( values ) && values.length )
{
for (var i = 0; i < values.length; i++)
{
var value = values[ i ];
var k = this.indexOf( value, equals );
if ( k !== -1 )
{
removedIndices.push( k );
removed.push( value );
}
}
removedIndices.sort();
for (var i = removedIndices.length - 1; i >= 0; i--)
{
AP.splice.call( this, removedIndices[ i ], 1 );
}
this.trigger( Collection.Events.Removes, [this, removed, removedIndices] );
if ( !delaySort )
{
this.sort( undefined, undefined, true );
}
}
return removed;
}
|
javascript
|
{
"resource": ""
}
|
|
q1789
|
train
|
function()
{
if ( AP.reverse )
{
AP.reverse.apply( this );
}
else
{
reverse( this );
}
this.trigger( Collection.Events.Updates, [this] );
return this;
}
|
javascript
|
{
"resource": ""
}
|
|
q1790
|
train
|
function(value, equals)
{
var equality = equals || equalsStrict;
for (var i = 0; i < this.length; i++)
{
if ( equality( value, this[ i ] ) )
{
return i;
}
}
return -1;
}
|
javascript
|
{
"resource": ""
}
|
|
q1791
|
train
|
function(comparator, startingValue)
{
var cmp = createComparator( comparator || this.comparator, false );
var min = startingValue;
for (var i = 0; i < this.length; i++)
{
if ( cmp( min, this[i] ) > 0 )
{
min = this[i];
}
}
return min;
}
|
javascript
|
{
"resource": ""
}
|
|
q1792
|
train
|
function(comparator, startingValue)
{
var cmp = createComparator( comparator || this.comparator, true );
var max = startingValue;
for (var i = 0; i < this.length; i++)
{
if ( cmp( max, this[i] ) < 0 )
{
max = this[i];
}
}
return max;
}
|
javascript
|
{
"resource": ""
}
|
|
q1793
|
train
|
function(properties, startingValue, compareFunction)
{
var comparator = compareFunction || compare;
var resolver = createPropertyResolver( properties );
var min = startingValue;
for (var i = 0; i < this.length; i++)
{
var resolved = resolver( this[ i ] );
if ( comparator( min, resolved, false ) > 0 )
{
min = resolved;
}
}
return min;
}
|
javascript
|
{
"resource": ""
}
|
|
q1794
|
train
|
function(properties, startingValue, compareFunction)
{
var comparator = compareFunction || compare;
var resolver = createPropertyResolver( properties );
var max = startingValue;
for (var i = 0; i < this.length; i++)
{
var resolved = resolver( this[ i ] );
if ( comparator( max, resolved, true ) < 0 )
{
max = resolved;
}
}
return max;
}
|
javascript
|
{
"resource": ""
}
|
|
q1795
|
train
|
function(whereProperties, whereValue, whereEquals)
{
var where = createWhere( whereProperties, whereValue, whereEquals );
for (var i = 0; i < this.length; i++)
{
var model = this[ i ];
if ( where( model ) )
{
return model;
}
}
return null;
}
|
javascript
|
{
"resource": ""
}
|
|
q1796
|
train
|
function(properties)
{
var resolver = createPropertyResolver( properties );
for (var i = 0; i < this.length; i++)
{
var resolved = resolver( this[ i ] );
if ( isValue( resolved ) )
{
return resolved;
}
}
}
|
javascript
|
{
"resource": ""
}
|
|
q1797
|
train
|
function(properties, value, equals)
{
var where = createWhere( properties, value, equals );
for (var i = this.length - 1; i >= 0; i--)
{
var model = this[ i ];
if ( where( model ) )
{
return model;
}
}
return null;
}
|
javascript
|
{
"resource": ""
}
|
|
q1798
|
train
|
function(resolver, validator, process, getResult)
{
for (var i = 0; i < this.length; i++)
{
var resolved = resolver( this[ i ] );
if ( validator( resolved ) )
{
process( resolved );
}
}
return getResult();
}
|
javascript
|
{
"resource": ""
}
|
|
q1799
|
train
|
function(numbers)
{
var resolver = createNumberResolver( numbers );
var result = 0;
var total = 0;
function process(x)
{
result += x;
total++;
}
function getResult()
{
return total === 0 ? 0 : result / total;
}
return this.aggregate( resolver, isNumber, process, getResult );
}
|
javascript
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.