Calls a callback by looping over cluster workers

@method worketIterator

@param  {Function} callback

@return {void}
5904
function workerIterator (callback) {
  Object.keys(cluster.workers).forEach((index) => callback(cluster.workers[index]))
}
255533
function(callback) {

    this.start = new Date().getTime();

    async.series([
      // The checker makes sure that we have everything we need.
      this.checker.callback(this.checker.check),
      this.callback(this.generate)
    ], callback);
  }
927882
public void invokeMethod(String method, Object[] methodParams, IRemotingCallback callback) {
        try {
            RemotingWorker worker = new RemotingWorker(this, method, methodParams, callback);
            executor.execute(worker);
        } catch (Exception err) {
            log.warn("Exception invoking method: {}", method, err);
        }
    }
1145065
function(data, callback) {
		var set = _assembleTask(data, workFlow[meth][url].merg);
		if (set.err) throw new Error('Invalid workflow: ' + set.tasks);
		async.series(set.tasks, function(err, results) {
			return callback(err, {
				'sync': data.sync,
				'async': data.async,
				'merg': results
			});
		});
	}
1041624
function wrapWorkAndCallback(work, callback) {
  return function(err) {
    work.stop(err);
    callback.apply(this, arguments);
  };
}
1107346
function makeCallback(callback) {
  if (_.isFunction(callback)) {
    return callback;
  }
  var result = function() { return callback; };
  result._callback = callback;
  return result;
}
352740
function() {
		var c = this._callback;
		var p = this._pointer;
		if (c) {
			this.then(null, null);
			c.apply(p, arguments);
		} else {
			this._now = true;
		}
	}
598864
function startWorkers() {
        _.range(0, numWorkers).forEach(function (index) {
            workers.push(startWorker(startPort + index));
        });
    }
1129565
@SuppressWarnings({"unchecked"})
    public void loopOrSingle(final Object x, final IterCallback<V> callback) {
        if (x == null) {
            return;
        }

        //A collection
        if (x instanceof Collection<?>) {
            final Collection<?> l = (Collection<?>) x;
            for (final Object o : l) {
                callback.eval((V) o);
            }
            return;
        }

        //An array of Object[]
        if (x.getClass().isArray()) {
            for (final Object o : (Object[]) x) {
                callback.eval((V) o);
            }
            return;
        }

        callback.eval((V) x);
    }
1135324
function (tasks, callback) {
    if(typeof callback !== 'function'){
      return new Error('Second argument to ordenado must be a callback function');
    }
    if (!_isArray(tasks)) {
      var e = new Error('First argument to ordenado must be an array of functions');
      return callback(e);
    }
    if (!tasks.length) {
      var er = new Error('ordenado expects at least one task (function) to run');
      return callback(er);
    }
    var wrap = function (iterator) {
      return function (err) {
        if (err) {
          callback.apply(err, arguments);
        } else {
          var args = Array.prototype.slice.call(arguments, 1);
          var next = iterator.next();
          if (next) {
            args.push(wrap(next));
          } else {
            args.push(callback);
          }
          setTimeout(function () {
            iterator.apply(null, args);
          },0);
        }
      };
    };
    wrap(iterator(tasks))();
  }
184538
function(callback) {

				// optimize as many times as the user wants
				async.timesSeries(options.optimize.input.svgo, function(i, next) {

					// tell the user that we’re optimizing
					grunt.log.writeln('Optimizing inputs with SVGO (pass ' + (i + 1) + ' of ' + options.optimize.input.svgo + ')…');

					// asynchronously loop through the files
					async.each(task.files, function(file, callback2) {

						// create a promise to optimize the SVGs
						promise = optimizeSVGO(file, options);

						// when that promise is finished, print the results onscreen
						// (if we’re being verbose)
						// and continue onwards
						promise.done(function(results) {
							if (results) {
								grunt.verbose.ok(results);
							}
							callback2(null);
						});

					}, next);

				}, callback);

			}
319412
function(self, callback) {
  if (self.cursorState.killed) {
    setCursorNotified(self, callback);
    return true;
  }

  return false;
}
731383
function callbackWrapper() {
					callback && callback.apply( this, arguments );

					// Removed the just loaded script from the queue.
					pending.shift();

					loadNext.call( that );
				}
53286
function(callback) {
        var self = this;

        this.loadbalancer.updateNode(self, function(err, nodes) {
            if (err) {
                callback(err);
                return;
            }

            nodes.forEach(function(node) {
                if (node.id == self.id) {
                    self = node;
                }
            });

            callback(err);
        });
    }
976564
def _invoke_callbacks(self):
        """"""
        self.task_end_time = time.time()
        self.task_cost_time = self.task_end_time - self.task_start_time
        with self._condition:
            for callback in self._done_callbacks:
                try:
                    result = callback(self)
                    if callback in self._user_callbacks:
                        self._callback_result = result
                except Exception as e:
                    Config.main_logger.error("exception calling callback for %s" % e)
            self._condition.notify_all()
590120
function (data, callback) {
    if (typeof callback !== 'function') {
        this.debug("Registering dummy callback, because a response message is expected");
    } else {
        this.debug("Registering callback");
    }
    this.waitingCallbacks.push(callback);
    send.call(this, data);
}
92240
function (callback) {
            var i;

            for (i = 0; i < this.data.length; i += 1) {
                callback.call(this, this.data[i], i);
            }
            return this;
        }