Queues the function given with the first argument with the
        parameters given with the rest of the argument list.
969730
def handle(self, *args, **options):
        
        verbosity = int(options.get('verbosity', 1))
        timeout = options.get('timeout')
        queue = get_queue(options.get('queue'))
        job = queue.enqueue_call(args[0], args=args[1:], timeout=timeout)
        if verbosity:
            print('Job %s created' % job.id)
1170039
function (queueNumber, customParams, callback) {
      [queueNumber, customParams, callback] = doArgs(arguments, ['string|number', ['object', {}], 'function']);

      doRequest({
        urlPattern: [QUEUE_ITEM, queueNumber]
      }, customParams, callback);
    }
108416
function (params) {
            if (! this.active) {
                return;
            }

            var paramsArr = Array.prototype.slice.call(arguments),
                n = this._bindings.length,
                bindings;

            if (this.memorize) {
                this._prevParams = paramsArr;
            }

            if (! n) {
                //should come after memorize
                return;
            }

            bindings = this._bindings.slice(); //clone array in case add/remove items during dispatch
            this._shouldPropagate = true; //in case `halt` was called before dispatch or during the previous dispatch.

            //execute all callbacks until end of the list or until a callback returns `false` or stops propagation
            //reverse loop since listeners with higher priority will be added at the end of the list
            do { n--; } while (bindings[n] && this._shouldPropagate && bindings[n].execute(paramsArr) !== false);
        }
965138
function (args) {
                var refreshMgrInfo = this._registerInRefreshMgr();
                refreshMgrInfo.queue = null;
                if(refreshMgrInfo.refreshArgs && refreshMgrInfo.refreshArgs.animate){
                    args.animate = true;
                }
                refreshMgrInfo.refreshArgs = args;
            }
881586
function _start()
{
  // first argument – runner function
  var runner = arguments[0]
    // take away first argument
    , args   = Array.prototype.slice.call(arguments, 1)
      // second argument - input data
    , input  = args[0]
      // last argument - result callback
    , endCb  = streamify.callback.call(this, args[args.length - 1])
    ;

  args[args.length - 1] = endCb;
  // third argument - iterator
  args[1] = streamify.iterator.call(this, args[1]);

  // allow time for proper setup
  defer(function()
  {
    if (!this.destroyed)
    {
      this.terminator = runner.apply(null, args);
    }
    else
    {
      endCb(null, Array.isArray(input) ? [] : {});
    }
  }.bind(this));
}
886996
function processQueue(queue, value) {
            if (!queue || queue.length === 0) return;
            var handler, i = 0;

            while (handler = queue[i++]) {
                handler(value);
            }
        }
179056
function (task, argument, callback) {
        var self = this;
        var queueArgument = {
            task: task,
            argument: argument
        };

        return promiseOrCallback(callback, function (resolve, reject) {
            self.taskQueue.push(queueArgument, function (error, result) {
                if (error) {
                    reject(error);
                } else {
                    resolve(result);
                }
            });
        });
    }
621073
public static void main(String[] args) {
    FixedPrioritiesPriorityQueue<String> pq = new FixedPrioritiesPriorityQueue<String>();
    System.out.println(pq);
    pq.add("one",1);
    System.out.println(pq);
    pq.add("three",3);
    System.out.println(pq);
    pq.add("one",1.1);
    System.out.println(pq);
    pq.add("two",2);
    System.out.println(pq);
    System.out.println(pq.toString(2));
    while (pq.hasNext()) {
      System.out.println(pq.next());
    }
  }
684503
def Queue(self, name, initial=None, maxsize=None):
        
        return types.Queue(name, self.api, initial=initial, maxsize=maxsize)
437508
def request(self, *args, **kwargs):
        
        func = partial(super().request, *args, **kwargs)
        return self.loop.run_in_executor(self.thread_pool, func)
658476
function enqueue(){
		var tasks = argumentFilter(arguments);
		queued.push({ tasks:tasks });
		// Timeout needed to increment expected, if next item exists.
		// If it run without timeout, expected always be 0 and the functions
		// will be executed immediately obtaining undefined as parameter.
		setTimeout(function(){if (! expected) runQueue();},1);
		return enqueue;
	}
274791
function enqueue(fn) {
  window._vis_opt_queue = window._vis_opt_queue || [];
  window._vis_opt_queue.push(fn);
}
642044
function QueueEntry(url, success, error, queue) {
    var _this = this;

    // A list of callbacks that will be called. Supports multiple callbacks.
    this.callbacks = {
        success: [success],
        error: [error]
        /**
         * @type {string}
         */
    };this.url = url;
    /**
     * Passes all the arguments to LoadSuccess
     * @type {function}
     */
    this.success = function () {
        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
            args[_key] = arguments[_key];
        }

        runCallbacks(_this.callbacks.success, function (callback) {
            callback.apply(undefined, [url].concat(args));
        });
    };
    /**
     * @type {function}
     * @param {Error} errorObject
     */
    this.error = function (errorObject) {
        runCallbacks(_this.callbacks.success, function (callback) {
            callback(url, errorObject);
        });
    };

    /**
     * Cancels loading - removes the image
     */
    this.cancel = function () {
        queue.cancel(_this);
    };

    /**
     * @type {LoadTask|null}
     */
    this.task = null;
}
755901
def queue_once_key(name, kwargs, restrict_to=None):
    
    keys = ['qo', force_string(name)]
    # Restrict to only the keys allowed in keys.
    if restrict_to is not None:
        restrict_kwargs = {key: kwargs[key] for key in restrict_to}
        keys += kwargs_to_list(restrict_kwargs)
    else:
        keys += kwargs_to_list(kwargs)
    key = "_".join(keys)
    return key
269709
def put(self, event, *args, **kwargs):
        
        self._queue.put((event, args, kwargs))
957915
async def purgeQueues(self, *args, **kwargs):
        

        return await self._makeApiCall(self.funcinfo["purgeQueues"], *args, **kwargs)
764724
def queue(name, arguments = {})
      with_bunny_precondition_handler('queue') do
        namespace = @config[:namespace].to_s.downcase.gsub(/[^-_:\.\w]/, "")
        name = name.prepend(namespace + ":") if namespace.present?
        channel.queue(name, durable: true, arguments: arguments)
      end
    end