_id
stringlengths 2
6
| title
stringlengths 0
58
| partition
stringclasses 3
values | text
stringlengths 27
233k
| language
stringclasses 1
value | meta_information
dict |
---|---|---|---|---|---|
q500 | colorize | train | function colorize(color, str) {
return str
.split('\n')
| javascript | {
"resource": ""
} |
q501 | formatTrace | train | function formatTrace(level, context, message, args, err) {
var recontext = {
time: (new Date()).toISOString(),
lvl: level,
corr: context.corr || notAvailable,
trans: context.trans || notAvailable,
op: context.op || notAvailable
};
Object.keys(context)
.filter((key) => {
return !(context[key] && Object.prototype.toString.call(context[key]) === '[object Function]');
| javascript | {
"resource": ""
} |
q502 | formatJsonTrace | train | function formatJsonTrace(level, context, message, args, err) {
| javascript | {
"resource": ""
} |
q503 | makeRespondMiddleware | train | function makeRespondMiddleware(opts) {
opts = Object.assign({}, opts)
// Make the respond function.
const respond = makeRespond(opts)
/**
* Installs the functions in the context.
*
* @param {KoaContext} ctx
*/
function patch(ctx) {
const statusMethods = Object.assign({}, opts.statusMethods, statusCodeMap)
ctx.send = respond.bind(ctx, ctx)
// Bind status methods.
for (const method in statusMethods) {
const code = statusMethods[method]
ctx[method] = respond.bind(ctx, ctx, code)
}
// Bind other methods
const methods = Object.assign({}, opts.methods)
for (const method in methods) {
const fn = methods[method]
ctx[method] = | javascript | {
"resource": ""
} |
q504 | patch | train | function patch(ctx) {
const statusMethods = Object.assign({}, opts.statusMethods, statusCodeMap)
ctx.send = respond.bind(ctx, ctx)
// Bind status methods.
for (const method in statusMethods) {
const code = statusMethods[method]
ctx[method] = respond.bind(ctx, ctx, code)
}
// Bind other methods | javascript | {
"resource": ""
} |
q505 | bundle | train | function bundle() {
return new Promise((resolve, reject) => {
webpack(webpackConfig).run((err, stats) => { | javascript | {
"resource": ""
} |
q506 | detectExtension | train | function detectExtension() {
var mimeType = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
var favoredExtension = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
mimeType = mimeType.toString().toLowerCase().replace(/\s/g, '');
if (!(mimeType in _listTypes.types)) {
return 'bin';
}
if (typeof _listTypes.types[mimeType] === 'string') {
return _listTypes.types[mimeType];
}
favoredExtension = favoredExtension.toString().toLowerCase().replace(/\s/g, '');
if (favoredExtension && _listTypes.types[mimeType].includes(favoredExtension)) {
return favoredExtension;
}
| javascript | {
"resource": ""
} |
q507 | mapSync | train | function mapSync(transformation) {
return through2.obj(function write(chunk, _, callback) {
let mappedData;
try {
mappedData = transformation(chunk);
} catch (error) {
callback(error);
}
| javascript | {
"resource": ""
} |
q508 | resolveNewPath | train | function resolveNewPath(newBase) {
return mapSync(file => { | javascript | {
"resource": ""
} |
q509 | train | function(modulesPath, viewsPath, areasPath) {
modulesPath = modulesPath || 'viewmodels';
viewsPath = viewsPath || 'views';
areasPath = areasPath || viewsPath;
var reg = new RegExp(escape(modulesPath), 'gi');
this.convertModuleIdToViewId = function (moduleId) { | javascript | {
"resource": ""
} |
|
q510 | train | function(obj, area, elementsToSearch) {
var view;
if (obj.getView) {
view = obj.getView();
if (view) {
return this.locateView(view, area, elementsToSearch);
}
}
if (obj.viewUrl) {
return this.locateView(obj.viewUrl, area, elementsToSearch);
}
var id = system.getModuleId(obj);
| javascript | {
"resource": ""
} |
|
q511 | train | function (obj) {
var funcNameRegex = /function (.{1,})\(/;
var results = (funcNameRegex).exec((obj).constructor.toString());
| javascript | {
"resource": ""
} |
|
q512 | train | function(viewOrUrlOrId, area, elementsToSearch) {
if (typeof viewOrUrlOrId === 'string') {
var viewId;
if (viewEngine.isViewUrl(viewOrUrlOrId)) {
viewId = viewEngine.convertViewUrlToViewId(viewOrUrlOrId);
} else {
viewId = viewOrUrlOrId;
}
if (area) {
viewId = this.translateViewIdToArea(viewId, area);
| javascript | {
"resource": ""
} |
|
q513 | processCompressedData | train | function processCompressedData (o) {
// Save the packet counter
o.lastSampleNumber = parseInt(o.rawDataPacket[0]);
const samples = [];
// Decompress the buffer into array
if (o.lastSampleNumber <= k.OBCIGanglionByteId18Bit.max) {
decompressSamples(o, decompressDeltas18Bit(o.rawDataPacket.slice(k.OBCIGanglionPacket18Bit.dataStart, k.OBCIGanglionPacket18Bit.dataStop)));
samples.push(buildSample(o.lastSampleNumber * 2 - 1, o.decompressedSamples[1], o.sendCounts));
samples.push(buildSample(o.lastSampleNumber * 2, o.decompressedSamples[2], o.sendCounts));
switch (o.lastSampleNumber % 10) {
case k.OBCIGanglionAccelAxisX:
o.accelArray[0] = o.sendCounts ? o.rawDataPacket.readInt8(k.OBCIGanglionPacket18Bit.auxByte - 1) : o.rawDataPacket.readInt8(k.OBCIGanglionPacket18Bit.auxByte - 1) * k.OBCIGanglionAccelScaleFactor;
break;
case k.OBCIGanglionAccelAxisY:
o.accelArray[1] = o.sendCounts ? o.rawDataPacket.readInt8(k.OBCIGanglionPacket18Bit.auxByte - 1) : o.rawDataPacket.readInt8(k.OBCIGanglionPacket18Bit.auxByte - 1) * k.OBCIGanglionAccelScaleFactor;
break;
case k.OBCIGanglionAccelAxisZ:
o.accelArray[2] = o.sendCounts ? o.rawDataPacket.readInt8(k.OBCIGanglionPacket18Bit.auxByte - 1) : o.rawDataPacket.readInt8(k.OBCIGanglionPacket18Bit.auxByte - | javascript | {
"resource": ""
} |
q514 | processImpedanceData | train | function processImpedanceData (o) {
const byteId = parseInt(o.rawDataPacket[0]);
let channelNumber;
switch (byteId) {
case k.OBCIGanglionByteIdImpedanceChannel1:
channelNumber = 1;
break;
case k.OBCIGanglionByteIdImpedanceChannel2:
channelNumber = 2;
break;
case k.OBCIGanglionByteIdImpedanceChannel3:
channelNumber = 3;
| javascript | {
"resource": ""
} |
q515 | processMultiBytePacket | train | function processMultiBytePacket (o) {
if (o.multiPacketBuffer) {
o.multiPacketBuffer = Buffer.concat([Buffer.from(o.multiPacketBuffer), Buffer.from(o.rawDataPacket.slice(k.OBCIGanglionPacket19Bit.dataStart, k.OBCIGanglionPacket19Bit.dataStop))]);
} else {
| javascript | {
"resource": ""
} |
q516 | processMultiBytePacketStop | train | function processMultiBytePacketStop (o) {
processMultiBytePacket(o);
const str = o.multiPacketBuffer.toString();
| javascript | {
"resource": ""
} |
q517 | decompressSamples | train | function decompressSamples (o, receivedDeltas) {
// add the delta to the previous value
for (let i = 1; i < 3; i++) {
for (let j = 0; j < 4; j++) | javascript | {
"resource": ""
} |
q518 | buildSample | train | function buildSample (sampleNumber, rawData, sendCounts) {
let sample;
if (sendCounts) {
sample = newSampleNoScale(sampleNumber);
sample.channelDataCounts = rawData;
| javascript | {
"resource": ""
} |
q519 | processRouteSampleData | train | function processRouteSampleData (o) {
if (parseInt(o.rawDataPacket[0]) === k.OBCIGanglionByteIdUncompressed) {
| javascript | {
"resource": ""
} |
q520 | processUncompressedData | train | function processUncompressedData (o) {
// Resets the packet counter back to zero
o.lastSampleNumber = k.OBCIGanglionByteIdUncompressed; // used to find dropped packets
for (let i = 0; i < 4; i++) {
o.decompressedSamples[0][i] | javascript | {
"resource": ""
} |
q521 | convertGanglionArrayToBuffer | train | function convertGanglionArrayToBuffer (arr, data) {
for (let i = 0; i < k.OBCINumberOfChannelsGanglion; i++) {
data.writeInt16BE(arr[i] >> 8, | javascript | {
"resource": ""
} |
q522 | getBooleanFromRegisterQuery | train | function getBooleanFromRegisterQuery (str, regEx, offset) {
let regExArr = str.match(regEx);
if (regExArr) {
const num = parseInt(str.charAt(regExArr.index + offset)); | javascript | {
"resource": ""
} |
q523 | getNumFromThreeCSVADSRegisterQuery | train | function getNumFromThreeCSVADSRegisterQuery (str, regEx, offset) {
let regExArr = str.match(regEx);
if (regExArr) {
const bit2 = parseInt(str.charAt(regExArr.index + offset));
const bit1 = parseInt(str.charAt(regExArr.index + offset | javascript | {
"resource": ""
} |
q524 | setChSetFromADSRegisterQuery | train | function setChSetFromADSRegisterQuery (str, channelSettings) {
let key = k.OBCIRegisterQueryNameCHnSET[channelSettings.channelNumber];
if (key === undefined) key = k.OBCIRegisterQueryNameCHnSET[channelSettings.channelNumber - k.OBCINumberOfChannelsCyton];
channelSettings.powerDown = getBooleanFromRegisterQuery(str, key, 16);
| javascript | {
"resource": ""
} |
q525 | getFirmware | train | function getFirmware (dataBuffer) {
const regexPattern = /v\d.\d*.\d*/;
const ret = dataBuffer.toString().match(regexPattern);
if (ret) {
const elems = ret[0].split('.');
return {
| javascript | {
"resource": ""
} |
q526 | train | function(obj) {
if (!obj) {
return null;
}
if (typeof obj == 'function') {
return obj.prototype.__moduleId__;
}
| javascript | {
"resource": ""
} |
|
q527 | train | function(obj, id) {
if (!obj) {
return;
}
if (typeof obj == 'function') {
obj.prototype.__moduleId__ = id;
return;
| javascript | {
"resource": ""
} |
|
q528 | train | function() {
var modules,
first = arguments[0],
arrayRequest = false;
if(system.isArray(first)){
modules = first;
arrayRequest = true;
}else{
modules = slice.call(arguments, 0);
}
return this.defer(function(dfd) {
require(modules, function() {
var args = arguments;
setTimeout(function() {
| javascript | {
"resource": ""
} |
|
q529 | train | function(obj) {
var rest = slice.call(arguments, 1);
for (var i = 0; i < rest.length; i++) {
var source = rest[i];
| javascript | {
"resource": ""
} |
|
q530 | validation | train | function validation() {
const target = this._obj;
this.assert(_.isObject(target), '#{this} is not a Joi validation because it must be an object');
this.assert(!_.isEmpty(target), '#{this} is not a Joi validation because it is an empty object');
const fields = _.keys(target);
const | javascript | {
"resource": ""
} |
q531 | validate | train | function validate() {
const target = this._obj;
isValidation(target);
this.assert(_.has(target, 'error') && | javascript | {
"resource": ""
} |
q532 | value | train | function value(utils) {
const target = this._obj,
value = target.value || null;
isValidation(target);
this.assert(null !== value,
'#{this} should have value',
| javascript | {
"resource": ""
} |
q533 | train | function(config, baseUrl){
var pluginIds = system.keys(config);
baseUrl = baseUrl || 'plugins/';
if(baseUrl.indexOf('/', baseUrl.length - 1) === -1){
baseUrl += '/';
}
for(var i = 0; i < pluginIds.length; i++){
var key = | javascript | {
"resource": ""
} |
|
q534 | train | function() {
system.log('Application:Starting');
if (this.title) {
document.title = this.title;
}
return system.defer(function (dfd) {
| javascript | {
"resource": ""
} |
|
q535 | K8sutil | train | function K8sutil() {
// this.getNamespace();
podName = os.hostname();
podGenerateName = podName.substr(0, podName.lastIndexOf('-'));
logger.debug('k8sutil', 'K8sutil()', 'The pod name: ', podName);
fetchContainerID();
try {
// var kubeconfig = Api.config.fromKubeconfig();
var kubeconfig = Api.config.getInCluster();
kubeconfig.promises = true;
// kubeconfig.namespace = 'default';
logger.debug('k8sutil', 'K8sutil()', 'Kubeconfig', kubeconfig);
core = new Api.Core(kubeconfig);
ext = new Api.Extensions(kubeconfig);
namespace = core.namespaces.namespace;
logger.info('k8sutil', 'K8sutil()', 'Current namespace', namespace);
if (!podJson) {
| javascript | {
"resource": ""
} |
q536 | Actor | train | function Actor(stream) {
if (!(this instanceof Actor)) return new Actor(stream);
var that = this;
this.parser = new amp.Stream;
this.parser.on('data', this.onmessage.bind(this));
stream.pipe(this.parser);
this.stream = stream; | javascript | {
"resource": ""
} |
q537 | reply | train | function reply(id, args) {
var msg = new Array(2 + args.length);
msg[0] = '_reply_'; | javascript | {
"resource": ""
} |
q538 | inputTypeForCommand | train | function inputTypeForCommand (cmd) {
switch (String(cmd)) {
case obciChannelCmdADCNormal:
return obciStringADCNormal;
case obciChannelCmdADCShorted:
return obciStringADCShorted;
case obciChannelCmdADCBiasMethod:
return obciStringADCBiasMethod;
case obciChannelCmdADCMVDD:
return obciStringADCMvdd;
case obciChannelCmdADCTemp:
return obciStringADCTemp;
case obciChannelCmdADCTestSig:
| javascript | {
"resource": ""
} |
q539 | gainForCommand | train | function gainForCommand (cmd) {
switch (String(cmd)) {
case obciChannelCmdGain1:
return 1;
case obciChannelCmdGain2:
return 2;
case obciChannelCmdGain4:
return 4;
case obciChannelCmdGain6:
return 6;
case obciChannelCmdGain8:
return 8;
case obciChannelCmdGain12:
| javascript | {
"resource": ""
} |
q540 | handleGuardedRoute | train | function handleGuardedRoute(activator, instance, instruction) {
var resultOrPromise = router.guardRoute(instance, instruction);
if (resultOrPromise) {
if (resultOrPromise.then) {
resultOrPromise.then(function(result) {
if (result) {
if (system.isString(result)) {
redirect(result);
} else {
activateRoute(activator, instance, instruction);
}
} else {
cancelNavigation(instance, instruction);
| javascript | {
"resource": ""
} |
q541 | train | function( error ) {
if( error instanceof Buffer && error.toString().match( | javascript | {
"resource": ""
} |
|
q542 | train | function(kind) {
ko.bindingHandlers[kind] = {
init: function() {
return { controlsDescendantBindings: true };
},
update: function(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {
var settings = widget.getSettings(valueAccessor);
settings.kind = kind;
extractParts(element, settings);
| javascript | {
"resource": ""
} |
|
q543 | train | function(kind, viewId, moduleId) {
if (viewId) {
kindViewMaps[kind] = viewId;
}
if (moduleId) {
| javascript | {
"resource": ""
} |
|
q544 | train | function(element, settings, bindingContext, fromBinding) {
if(!fromBinding){
settings = widget.getSettings(function() { return settings; }, | javascript | {
"resource": ""
} |
|
q545 | train | function(config){
config.bindingName = config.bindingName || 'widget';
if(config.kinds){
var toRegister = config.kinds;
for(var i = 0; i < toRegister.length; i++){
widget.registerKind(toRegister[i]);
}
}
ko.bindingHandlers[config.bindingName] = {
init: function() {
return { controlsDescendantBindings: true };
},
update: function(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {
| javascript | {
"resource": ""
} |
|
q546 | train | function(value) {
if(system.isObject(value)) {
value = value.can || false;
}
if(system.isString(value)) {
| javascript | {
"resource": ""
} |
|
q547 | cloneWrap | train | function cloneWrap(obj, circularValue) {
circularValue = safeDeepClone(undefined, [], circularValue);
| javascript | {
"resource": ""
} |
q548 | train | function(opts) {
this.load_balancer = opts.load_balancer;
this.task_manager = opts.task_manager;
this.file_manager = opts.file_manager;
this.net_manager = | javascript | {
"resource": ""
} |
|
q549 | train | function(bindingContext, view, obj) {
if (obj && bindingContext) {
bindingContext = bindingContext.createChildContext(obj);
}
| javascript | {
"resource": ""
} |
|
q550 | train | function(allElements){
if (allElements.length == 1) {
return allElements[0];
}
var withoutCommentsOrEmptyText = [];
for (var i = 0; i < allElements.length; i++) {
var current = allElements[i];
if (current.nodeType != 8) {
if (current.nodeType == 3) {
var result = /\S/.test(current.nodeValue);
if (!result) {
continue;
}
}
| javascript | {
"resource": ""
} |
|
q551 | train | function(viewId) {
var that = this;
var requirePath = this.convertViewIdToRequirePath(viewId);
return system.defer(function(dfd) {
system.acquire(requirePath).then(function(markup) {
var element = that.processMarkup(markup);
element.setAttribute('data-view', viewId);
dfd.resolve(element);
}).fail(function(err){
| javascript | {
"resource": ""
} |
|
q552 | train | function (viewId, requirePath, err) {
var that = this,
message = 'View Not Found. Searched for "' + viewId + '" via path "' + requirePath + '".';
return system.defer(function(dfd) {
| javascript | {
"resource": ""
} |
|
q553 | train | function(message, title, options) {
this.message = message;
this.title = title || MessageBox.defaultTitle;
| javascript | {
"resource": ""
} |
|
q554 | train | function(obj){
var theDialog = this.getDialog(obj);
if(theDialog){
var rest = Array.prototype.slice.call(arguments, 1);
| javascript | {
"resource": ""
} |
|
q555 | train | function(obj, activationData, context) {
var that = this;
var dialogContext = contexts[context || 'default'];
return system.defer(function(dfd) {
ensureDialogInstance(obj).then(function(instance) {
var dialogActivator = activator.create();
dialogActivator.activateItem(instance, activationData).then(function (success) {
if (success) {
var theDialog = instance.__dialog__ = {
owner: instance,
context: dialogContext,
activator: dialogActivator,
close: function () {
var args = arguments;
dialogActivator.deactivateItem(instance, true).then(function (closeSuccess) {
if (closeSuccess) {
dialogCount--;
dialogContext.removeHost(theDialog);
delete instance.__dialog__;
if (args.length === 0) {
dfd.resolve();
| javascript | {
"resource": ""
} |
|
q556 | train | function(message, title, options){
if(system.isString(this.MessageBox)){
return dialog.show(this.MessageBox, [
message,
title || MessageBox.defaultTitle,
| javascript | {
"resource": ""
} |
|
q557 | train | function(config){
app.showDialog = function(obj, activationData, context) {
return dialog.show(obj, activationData, context);
};
app.showMessage = function(message, title, options) {
return dialog.showMessage(message, title, options);
};
if(config.messageBox){
dialog.MessageBox = config.messageBox;
}
| javascript | {
"resource": ""
} |
|
q558 | train | function(theDialog) {
var body = $('body');
var blockout = $('<div class="modalBlockout"></div>')
.css({ 'z-index': dialog.getNextZIndex(), 'opacity': this.blockoutOpacity })
.appendTo(body);
var host = $('<div class="modalHost"></div>')
.css({ 'z-index': dialog.getNextZIndex() })
.appendTo(body);
theDialog.host = host.get(0);
theDialog.blockout = blockout.get(0);
if (!dialog.isOpen()) {
theDialog.oldBodyMarginRight = body.css("margin-right");
theDialog.oldInlineMarginRight = body.get(0).style.marginRight;
var html | javascript | {
"resource": ""
} |
|
q559 | train | function(theDialog) {
$(theDialog.host).css('opacity', 0);
$(theDialog.blockout).css('opacity', 0);
setTimeout(function() {
ko.removeNode(theDialog.host);
ko.removeNode(theDialog.blockout);
}, this.removeDelay);
if (!dialog.isOpen()) {
var html = $("html");
var oldScrollTop = html.scrollTop(); // necessary for Firefox.
html.css("overflow-y", "").scrollTop(oldScrollTop);
| javascript | {
"resource": ""
} |
|
q560 | train | function (child, parent, context) {
var theDialog = dialog.getDialog(context.model);
var $child = $(child);
var loadables = $child.find("img").filter(function () {
//Remove images with known width and height
var $this = $(this);
return !(this.style.width && this.style.height) && !($this.attr("width") && $this.attr("height"));
});
$child.data("predefinedWidth", $child.get(0).style.width);
var setDialogPosition = function () {
//Setting a short timeout is need in IE8, otherwise we could do this straight away
setTimeout(function () {
//We will clear and then set width for dialogs without width set
if (!$child.data("predefinedWidth")) {
$child.css({ width: '' }); //Reset width
}
var width = $child.outerWidth(false);
var height = $child.outerHeight(false);
var windowHeight = $(window).height();
var constrainedHeight = Math.min(height, windowHeight);
$child.css({
'margin-top': (-constrainedHeight / 2).toString() + 'px',
'margin-left': (-width / 2).toString() + 'px'
});
if (!$child.data("predefinedWidth")) {
//Ensure the correct width after margin-left has been set
$child.outerWidth(width);
| javascript | {
"resource": ""
} |
|
q561 | train | function(name, config, initOptionsFactory){
var key,
dataKey = 'composition-handler-' + name,
handler;
config = config || ko.bindingHandlers[name];
initOptionsFactory = initOptionsFactory || function(){ return undefined; };
handler = ko.bindingHandlers[name] = {
init: function(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {
if(compositionCount > 0){
var data = {
trigger:ko.observable(null)
};
composition.current.complete(function(){
if(config.init){
config.init(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext);
}
if(config.update){
ko.utils.domData.set(element, dataKey, config);
data.trigger('trigger');
}
});
ko.utils.domData.set(element, dataKey, data);
}else{
ko.utils.domData.set(element, dataKey, config);
if(config.init){
config.init(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext);
}
| javascript | {
"resource": ""
} |
|
q562 | train | function(elements, parts, isReplacementSearch) {
parts = parts || {};
if (!elements) {
return parts;
}
if (elements.length === undefined) {
elements = [elements];
}
for (var i = 0, length = elements.length; i < length; i++) {
var element = elements[i];
if (element.getAttribute) {
if(!isReplacementSearch && hasComposition(element)){
continue;
}
var id = element.getAttribute(partAttributeName);
if (id) {
| javascript | {
"resource": ""
} |
|
q563 | train | function (element, settings, bindingContext, fromBinding) {
compositionCount++;
if(!fromBinding){
settings = composition.getSettings(function() { return settings; }, element);
}
if (settings.compositionComplete) {
compositionCompleteCallbacks.push(function () {
settings.compositionComplete(settings.child, settings.parent, settings);
});
}
compositionCompleteCallbacks.push(function () {
if(settings.composingNewView && settings.model && settings.model.compositionComplete){
settings.model.compositionComplete(settings.child, settings.parent, settings);
}
});
var hostState = getHostState(element);
settings.activeView = hostState.activeView;
settings.parent = element;
settings.triggerAttach = triggerAttach;
settings.bindingContext = bindingContext;
if (settings.cacheViews && !settings.viewElements) {
settings.viewElements = hostState.childElements;
}
if (!settings.model) {
if (!settings.view) {
| javascript | {
"resource": ""
} |
|
q564 | removeFailedPredicate | train | function removeFailedPredicate(predicates, items) {
return | javascript | {
"resource": ""
} |
q565 | train | function(object, settings) {
settings = (settings === undefined) ? {} : settings;
if(system.isString(settings) || system.isNumber(settings)) {
settings = { space: settings };
} | javascript | {
"resource": ""
} |
|
q566 | train | function(key, value, getTypeId, getConstructor) {
var typeId = getTypeId(value);
if (typeId) {
var ctor = getConstructor(typeId);
if (ctor) {
if (ctor.fromJSON) {
return ctor.fromJSON(value);
| javascript | {
"resource": ""
} |
|
q567 | train | function(text, settings) {
var that = this;
settings = settings || {};
var getTypeId = settings.getTypeId || function(object) { return that.getTypeId(object); };
var getConstructor = settings.getConstructor || function(id) { return that.typeMap[id]; };
var reviver | javascript | {
"resource": ""
} |
|
q568 | train | function(opts) {
if (!opts) opts = {};
this.port_offset = opts.port_offset ? parseInt(opts.port_offset) : 10001;
this.task_list = {};
this.can_accept_queries = false;
this.can_local_compute = true;
this.app_folder = opts.app_folder;
var pm2_opts = {};
if (process.env.NODE_ENV == 'test') {
pm2_opts = {
independent : true,
daemon_mode : true | javascript | {
"resource": ""
} |
|
q569 | convertProperty | train | function convertProperty(obj, propertyName, original){
var observable,
isArray,
lookup = obj.__observable__ || (obj.__observable__ = {});
if(original === undefined){
original = obj[propertyName];
}
if (system.isArray(original)) {
observable = ko.observableArray(original);
makeObservableArray(original, observable);
isArray = true;
} else if (typeof original == "function") {
if(ko.isObservable(original)){
observable = original;
}else{
return null;
}
} else if(system.isPromise(original)) {
observable = ko.observable();
original.then(function (result) {
if(system.isArray(result)) {
var oa = ko.observableArray(result);
makeObservableArray(result, oa);
result = oa;
}
observable(result);
| javascript | {
"resource": ""
} |
q570 | defineProperty | train | function defineProperty(obj, propertyName, evaluatorOrOptions) {
var computedOptions = { owner: obj, deferEvaluation: true },
computed;
if (typeof evaluatorOrOptions === 'function') {
computedOptions.read = evaluatorOrOptions;
} else {
if ('value' in evaluatorOrOptions) {
system.error('For defineProperty, you must not specify a "value" for the property. You must provide a "get" function.');
}
if (typeof evaluatorOrOptions.get !== 'function') {
system.error('For defineProperty, the third parameter must be either an evaluator function, or an options object | javascript | {
"resource": ""
} |
q571 | _libraryFiles | train | function _libraryFiles(directory) {
return new Promise((fulfill) => {
const files = [];
klaw(directory)
.on('data', (item) | javascript | {
"resource": ""
} |
q572 | train | function (url, query, callbackParam) {
if (url.indexOf('=?') == -1) {
callbackParam = callbackParam || this.callbackParam;
if (url.indexOf('?') == -1) {
url += '?';
} else {
url += '&';
| javascript | {
"resource": ""
} |
|
q573 | train | function(url, data) {
return $.ajax({
url: url,
data: ko.toJSON(data),
| javascript | {
"resource": ""
} |
|
q574 | fsmEvent | train | function fsmEvent (start, events) {
if (typeof start === 'object') {
events = start
start = 'START'
}
assert.equal(typeof start, 'string')
assert.equal(typeof events, 'object')
assert.ok(events[start], 'invalid starting state ' + start)
assert.ok(fsm.validate(events))
const emitter = new EventEmitter()
emit._graph = fsm.reachable(events)
emit._emitter = emitter
emit._events = events
emit._state = start
emit.emit = emit
emit.on = on
return emit
// set a state listener
// str, fn -> null
function on (event, cb) {
emitter.on(event, cb)
}
// change the state
// str -> null
function emit (str) {
const nwState = emit._events[emit._state][str]
if (!reach(emit._state, nwState, emit._graph)) {
const err = 'invalid transition: ' + emit._state + ' -> ' + str
| javascript | {
"resource": ""
} |
q575 | emit | train | function emit (str) {
const nwState = emit._events[emit._state][str]
if (!reach(emit._state, nwState, emit._graph)) {
const err = 'invalid transition: ' + emit._state + ' -> ' + str
return emitter.emit('error', err)
}
const leaveEv = emit._state + ':leave'
const enterEv = nwState + ':enter'
if (!emit._state) return enter()
return leave()
function leave () {
if | javascript | {
"resource": ""
} |
q576 | reach | train | function reach (curr, next, reachable) {
if (!next) return false
if (!curr) return true
const here = reachable[curr] | javascript | {
"resource": ""
} |
q577 | LanguagePicker | train | function LanguagePicker(lang = 'en', config = {}) {
const scripts = ls.adjust({ override: dataOverrides });
this.userLang = lang;
this.nameTag = config.nameTag;
// The prefix is either given or is the nameTag
// with an underscore
// See Babel.js#24
this.prefix = config.multiTag || (this.nameTag && `${this.nameTag}_`) || '';
this.forceLocal = !!config.forceLocal;
if (this.forceLocal) {
// If we are forcing a local language, we don't need
// any of the fallback calculations
return;
}
// Store language script
this.langScript = scripts[lang] || 'Latn';
// Add known fallbacks for the language
let fallbacks;
if (config.languageMap) {
fallbacks = config.languageMap[lang];
if (fallbacks && !Array.isArray(fallbacks)) {
fallbacks = [fallbacks];
}
}
if (!fallbacks) {
fallbacks = [];
}
| javascript | {
"resource": ""
} |
q578 | PbfSplicer | train | function PbfSplicer(options) {
// tag which will be auto-removed and auto-injected. Usually 'name'
this.nameTag = options.nameTag;
// tag that contains JSON initially, and which works as a prefix for multiple values
this.multiTag = options.multiTag;
// If options.namePicker is given, | javascript | {
"resource": ""
} |
q579 | train | function(cb) {
var lockFile = path.join(repoDir, '.git', 'index.lock');
path.exists(lockFile, function(exists) {
if (exists) {
fs.unlink(lockFile, function(err) {
if (err) {
log.warn('removing file ' + lockFile + ' failed with:', err);
| javascript | {
"resource": ""
} |
|
q580 | train | function(cb) {
git(repoDir, ['status'], function(err, stdout, stderr) {
if (err) {
log.warn('git status failed on ' + repoDir + ":", err.msg);
var indexFile = path.join(repoDir, '.git', 'index');
path.exists(indexFile, function(exists) {
if (exists) {
fs.unlink(indexFile, function(err) {
if (err) {
log.warn('removing file ' + indexFile + ' failed with:', err);
}
else {
log.info('removed index file: ' + indexFile);
| javascript | {
"resource": ""
} |
|
q581 | train | function(cb) {
log.log('git remote prune origin ' + repoDir);
self.pruneOrigin(repoDir, function(err, stdout, stderr) {
if (err) {
| javascript | {
"resource": ""
} |
|
q582 | train | function(cb) {
log.log('git fetch origin ' + repoDir);
git(repoDir, ['fetch', 'origin'], function(err, stdout, stderr) {
if (err) {
| javascript | {
"resource": ""
} |
|
q583 | _ensureExists | train | function _ensureExists(dir, callback) {
dir = path.resolve(dir); // make full path
path.exists(dir, function(exists) {
if (!exists) {
// ensure that the parent dir exists
_ensureExists(path.dirname(dir), function(err) {
if (err) {
callback(err);
return;
}
// make the dir
log.log('Creating ' + dir);
fs.mkdir(dir, function(err) {
if (err) {
| javascript | {
"resource": ""
} |
q584 | combine | train | function combine(at, shares){
var setBits, share, x = [], y = [], result = '', idx;
for(var i=0, len = shares.length; i<len; i++){
share = processShare(shares[i]);
if(typeof setBits === 'undefined'){
setBits = share['bits'];
}else if(share['bits'] !== setBits){
throw new Error('Mismatched shares: Different bit settings.')
}
if(config.bits !== setBits){
init(setBits);
}
| javascript | {
"resource": ""
} |
q585 | lagrange | train | function lagrange(at, x, y){
var sum = 0,
product,
i, j;
for(var i=0, len = x.length; i<len; i++){
if(!y[i]){
continue;
}
product = config.logs[y[i]];
for(var j=0; j<len; j++){
if(i === j){ continue; }
if(at === x[j]){ // happens when computing a share that is in the list of shares used to compute it
product = -1; // fix for a zero product term, after which the sum should be sum^0 = sum, not sum^1
break;
} | javascript | {
"resource": ""
} |
q586 | padLeft | train | function padLeft(str, bits){
bits = bits || config.bits
var missing = str.length % bits;
return (missing ? new | javascript | {
"resource": ""
} |
q587 | getNotIncrementedTopicPayloads | train | function getNotIncrementedTopicPayloads(previousConsumerReadOffset, consumer) {
let notIncrementedTopicPayloads = consumer.topicPayloads.filter((topicPayload) => {
let {topic, partition, offset: currentOffset} = topicPayload;
let previousTopicPayloadForPartition = _.find(previousConsumerReadOffset, {topic, partition});
| javascript | {
"resource": ""
} |
q588 | isOffsetsInSync | train | function isOffsetsInSync(notIncrementedTopicPayloads, zookeeperOffsets, kafkaOffsetDiffThreshold, logger) {
logger.trace('Monitor Offset: Topics offsets', zookeeperOffsets);
let lastErrorToHealthCheck;
notIncrementedTopicPayloads.forEach(function (topicPayload) {
let {topic, partition, offset} = topicPayload;
if (zookeeperOffsets && zookeeperOffsets[topic] && zookeeperOffsets[topic][partition]) {
let zkLatestOffset = zookeeperOffsets[topic][partition][0];
let unhandledMessages = zkLatestOffset - offset;
if (unhandledMessages > kafkaOffsetDiffThreshold) {
let state = {
topic: topic,
partition: partition,
partitionLatestOffset: zkLatestOffset,
partitionReadOffset: offset,
unhandledMessages: unhandledMessages
};
| javascript | {
"resource": ""
} |
q589 | applyPatches | train | function applyPatches (versions) {
versions = sortVersions(versions, 'ASC')
let state = []
// iterate patches to the final one => get previous commit state
versions.forEach((v) => {
v.changes.forEach((c) => {
if (c.operation === 'insert') {
return state.push({
entityId: c.entityId,
entitySet: c.entitySet,
entity: parse(c.serializedDoc),
path: c.path
})
}
if | javascript | {
"resource": ""
} |
q590 | generateCodebook | train | function generateCodebook() {
var codebook = {};
reverse_codebook.forEach(function (value, i) {
| javascript | {
"resource": ""
} |
q591 | train | function (logLevel) {
return chalk.bg | javascript | {
"resource": ""
} |
|
q592 | train | function (logLevel, args) {
const time = dateFormat(new Date(), 'dd/mm/yyyy, h:MM:ss.l tt');
// Each logger can have its own name. If this is
// not provided, it will default to Unknown.
const loggerName = __private.name || Constants.LOG_UNKNOWN_APP_ID;
return [ (logLevel.name.length === 4 ? | javascript | {
"resource": ""
} |
|
q593 | train | function (name, state) {
if (!module.exports.operations.validateState || module.exports.operations.validateState(state)) {
module.exports.config.states[name] = state;
} else {
| javascript | {
"resource": ""
} |
|
q594 | train | function (sectionId, state) {
if (!module.exports.operations.validateState || module.exports.operations.validateState(state)) {
appState.set('state[' + sectionId + ']', state);
} else {
| javascript | {
"resource": ""
} |
|
q595 | train | function (state, transformation, res) {
if (!module.exports.operations.canTransform || !module.exports.operations.transform) {
log.warn('Transform State operation not implemented by application');
Utils.sendMessage(res, HttpStatus.NOT_IMPLEMENTED, JSON.stringify({ error: 'operation not implemented' }));
return state;
} else if (Utils.isNullOrEmpty(transformation)) {
log.error('Transformation not provided');
Utils.sendMessage(res, HttpStatus.BAD_REQUEST, JSON.stringify({ error: 'invalid | javascript | {
"resource": ""
} |
|
q596 | train | function (source, target, res) {
if (!module.exports.operations.canDiff || !module.exports.operations.diff) {
log.warn('Difference operation not implemented by application');
Utils.sendMessage(res, HttpStatus.NOT_IMPLEMENTED, JSON.stringify({ error: 'operation not implemented' }));
} else if (Utils.isNullOrEmpty(target)) {
log.error('Target state not provided');
Utils.sendMessage(res, HttpStatus.BAD_REQUEST, JSON.stringify({ error: 'invalid states' }));
} else if (!module.exports.operations.canDiff(source, target)) {
log.error('Unable to get difference | javascript | {
"resource": ""
} |
|
q597 | runPrompts | train | function runPrompts (opts) {
if (opts.questionnaire && this.init.configure) {
this.sprout.emit('msg', 'running questionnaire function')
const unansweredConfig = lodash.filter(this.init.configure, (q) => {
return !lodash.includes(lodash.keys(this.config), q.name)
| javascript | {
"resource": ""
} |
q598 | reverse | train | function reverse (arr) {
const reversedArray = [];
for (let i = arr.length - 1; i >= 0; i--) { | javascript | {
"resource": ""
} |
q599 | renderTemplateLoader | train | function renderTemplateLoader(source) {
// Get the loader options object.
var options = getOptions(this)
// Get the template locals.
var locals = getLocals.call(this, options)
// Create info object of the filename of the resource being loaded.
var info = { filename: this.resourcePath }
// Get the engine options to be passed to the engine.
var engineOptions = getEngineOptions.call(this, options.engineOptions, info)
// Get the template renderer
var renderer = getRenderer.call(this, options.engine)
// Call options.init.
| javascript | {
"resource": ""
} |