Define the queue
@public
346361
function define() {
    let aqOptions = getAssertQueueOptions();
    topLog.info(`Declaring queue \'${channelName}\' on connection \'${connectionName}\' with the options: ${JSON.stringify(_.omit(aqOptions, ['name']))}`);
    return channel.assertQueue(channelName, aqOptions);
  }
868359
function queueOrRequest( el ){
			var url = el.data( "url" );
			if( o.proxy && $.inArray( url, urllist ) === -1 ){
				urllist.push( url );
				elQueue = elQueue.add( el );
			}
			else{
				AI.makeReq( url, el );
			}
		}
1070266
function queue(name, parent, data) {
    this.length--;

    //
    // Object was queued, transform the response type to application/json.
    //
    if ('object' === typeof data && this._contentType !== contentTypes.json) {
      this.emit('contentType', 'json');
    }

    this._queue.push({
      parent: parent,
      name: name,
      view: data
    });

    return this;
  }
405771
function (end, clearQueue, queue) {
            var self = this;
            util.each(self, function (elem) {
                Anim.stop(elem, end, clearQueue, queue);
            });
            return self;
        }
743950
function () {

            var output = "",
                queueItem,
                q,
                nQueue = this.eventQueue.length;
              
            for (q = 0; q < nQueue; q++) {
                queueItem = this.eventQueue[q];
                if (queueItem) {
                    output += queueItem[0] + "=" + queueItem[1] + ", ";
                }
            }
            return output;
        }
1051306
function AmqpQueue(source) {
  assert.ok(source);
  TasksSource.Queue.apply(this, []);
  this.source = source;
  this._amqpProcessing = false;
}
304561
function (end, queue) {
            var self = this;
            util.each(self, function (elem) {
                Anim.resume(elem, queue);
            });
            return self;
        }
464763
function () {
            var fc = this.freeCount, def, defQueue = this.__deferredQueue;
            while (fc-- >= 0 && defQueue.count) {
                def = defQueue.dequeue();
                var conn = this.getObject();
                if (conn) {
                    def.callback(conn);
                } else {
                    throw new Error("UNEXPECTED ERROR");
                }
                fc--;
            }
        }
187643
function queue(steps) {
  var swal = this;
  currentSteps = steps;

  var resetQueue = function resetQueue() {
    currentSteps = [];
    document.body.removeAttribute('data-swal2-queue-step');
  };

  var queueResult = [];
  return new Promise(function (resolve) {
    (function step(i, callback) {
      if (i < currentSteps.length) {
        document.body.setAttribute('data-swal2-queue-step', i);
        swal(currentSteps[i]).then(function (result) {
          if (typeof result.value !== 'undefined') {
            queueResult.push(result.value);
            step(i + 1, callback);
          } else {
            resetQueue();
            resolve({
              dismiss: result.dismiss
            });
          }
        });
      } else {
        resetQueue();
        resolve({
          value: queueResult
        });
      }
    })(0);
  });
}
1010365
function done() {
        var index = queue.length;

        while (index--) {
            patch(queue[index], one(queue[index]));
        }
    }
273665
function(options) {
            this.queue.defer(function() {
                options = _.defaults(options || {}, {
                    refresh: false
                });
                var d, self = this;

                if (this.options.loader == null) return this;
                if (options.refresh) {
                    this.options.startIndex = 0;
                    this._totalCount = null;
                    this.reset([]);
                }

                if (this._totalCount == null || this.hasMore() > 0 || options.refresh) {
                    this.options.startIndex = this.options.startIndex || 0;
                    d = Q(this[this.options.loader].apply(this, this.options.loaderArgs || []));
                    d.done(function() {
                        self.options.startIndex = self.options.startIndex + self.options.limit
                    });
                } else {
                    d = Q.reject();
                }

                return d;
            }, this);

            return this;
        }
515434
@SuppressWarnings("unchecked")
  public T queue(Function... funcs) {
    for (Element e : elements()) {
      for (Function f : funcs) {
        queue(e, DEFAULT_NAME, f);
      }
    }
    return (T) this;
  }
654166
@SuppressWarnings("unchecked")
  public T queue(final String name, Function... funcs) {
    for (final Function f : funcs) {
      for (Element e : elements()) {
        queue(e, name, f);
      }
    }
    return (T) this;
  }
197874
public function queue()
    {
        if (is_null($this->queue)) {
            $this->queue = app(Queue::class);
        }

        return $this->queue;
    }
1284010
function createQueue() {
    var queues = [];
    for (var _i = 0; _i < arguments.length; _i++) {
        queues[_i] = arguments[_i];
    }
    var _queue;
    _queue = new GroupedQueue(chek_1.flatten(queues));
    return _queue;
}
410294
function runQueue(){
			if( urllist.length ){
				AI.makeReq( o.proxy + urllist.join( "," ), elQueue );
				elQueue = $();
				urllist = [];
			}
		}
1229251
function queue ({
  load,
  retry = 0

}) {

  const emitter = new EventEmitter()
  emitter.setMaxListeners(0)

  const results = {}

  function add (param = '', callback) {
    let key

    if (arguments.length === 1) {
      callback = param
      key = ''

    } else {
      key = JSON.stringify(param)
    }

    if (key in results) {
      return callback(...results[key])
    }

    emitter.on(key, callback)

    if (emitter.listenerCount(key) === 1) {
      loadResource(param, load, retry)
      .then((data) => {
        results[key] = [null, data]
        emitter.emit(key, null, data)
        emitter.removeAllListeners(key)
      })
      .catch((err) => {
        emitter.emit(key, err)
        // again
        emitter.removeAllListeners(key)
      })
    }
  }

  return {
    // expose cache so that we could handle it
    cache: results,
    add: (param) => {
      return new Promise((resolve, reject) => {
        add(param, (err, data) => {
          if (err) {
            return reject(err)
          }

          resolve(data)
        })
      })
    }
  }
}