Stub dispatch handler to queue dispatched messages until bridge is ready.

@param {String} name
191202
function (name) {
        (Array.isArray(this._pending) ? this._pending : (this._pending = [])).push(arguments);
        this.emit(DISPATCHQUEUE_EVENT, name);
    }
773522
function(eventName, listener) {
			if (typeof listener === "function" || listener.handleEvent) {
				this._namedListeners[eventName] = this._namedListeners[eventName] || [];
				this._namedListeners[eventName].push(listener);
			}
		}
202416
@SuppressWarnings("unchecked")
  public T dequeue(String name) {
    for (Element e : elements()) {
      dequeueCurrentAndRunNext(e, name);
    }
    return (T) this;
  }
210578
function(name) {
    for (var i = 0, len = this.asyncRules.length; i < len; i++) {
      if (this.asyncRules[i] === name) {
        return true;
      }
    }
    return false;
  }
718682
public void dispatchEvent(Event event, String eventName) {
    int typeInt = Event.getTypeInt(eventName);
    Object[] handlerData = $(element).data(EVENT_DATA);
    for (int i = 0, l = elementEvents.length(); i < l; i++) {
      BindFunction listener = elementEvents.get(i);
      String namespace = JsUtils.prop(event, "namespace");
      boolean matchEV = listener != null && (listener.hasEventType(typeInt) || listener.isTypeOf(eventName));
      boolean matchNS = matchEV && (isNullOrEmpty(namespace) || listener.nameSpace.equals(namespace));
      if (matchEV && matchNS) {
        if (!listener.fire(event, typeInt, eventName, handlerData)) {
          event.stopPropagation();
          event.preventDefault();
        }
      }
    }
  }
247140
function Queue(bus, name) {
  events.EventEmitter.call(this);
  this.setMaxListeners(0);
  this.bus = bus;
  this.type = 'queue';
  this.id = this.bus.options.layout === 'cluster' ? "{bus:queue:" + name + "}" : "bus:queue:" + name;
  this.logger = bus.logger.withTag(this.id);
  this.name = name;
  this._state = STATES.DETACHED;
  this.metadataKey = this.id + ":metadata";
  this.messagesKey = this.id + ":messages";
  this.messageIdKey = this.id + ":msgid";
  this.messagesToAckKey = this.id + ":toack";
  this.messageAvailableChannel = this.id + ":available";
  this.qKeys = [this.metadataKey, this.messagesKey, this.messageIdKey, this.messagesToAckKey];
  this.toucher = null;
  this._pushed = 0;
  this._consumed = 0;
}
6335
function (name, options, cb) {
                var engine = enginesByExtension[this.ext],
                    that = this,
                    // queue
                    stack = [],
                    ctx = {
                        name    : name,
                        options : options,
                        cb      : cb
                    };

                this.engines = engines;
                this.thru = function (name, _name, _options, _cb) {
                    var engine = engines[name];
                    if (!engine) {
                        return cb(Error('Unknown engine ' + name));
                    }
                    this.ext = engine.extension;
                    engine.call(this, _name || ctx.name, _options || ctx.options, _cb || ctx.cb);
                };

                options.forceLoad = options.hasOwnProperty('forceLoad') ? options.forceLoad : !expressBem.envLoadCache;
                options.forceExec = options.hasOwnProperty('forceExec') ? options.forceExec : !expressBem.envExecCache;

                if (!middlewares.length) {
                    return engine.call(this, ctx.name, ctx.options, ctx.cb);
                }

                // async fn queue
                middlewares.forEach(function (mw) {
                    if (!mw.engine /* || shouldUseMiddlewareFor(mw.engine)*/) {
                        stack.push(mw.fn);
                    }
                });

                // put engine as last call
                stack.push(function (ctx) {
                    engine.call(this, ctx.name, ctx.options, ctx.cb);
                });

                function next () {
                    var fn = stack.shift();
                    fn.call(that, ctx, next);
                }

                process.nextTick(next);

                return this;
            }
431198
function (dispatchEvents, name) {
  this.dispatchEvent = dispatchEvents;
  this.name = name;
  this.connection = freedom['core.rtcpeerconnection']();
  this.connection.on(function (type, msg) {
    if (type === 'onsignalingstatechange' ||
        type === 'onnegotiationneeded' ||
        type === 'oniceconnectionstatechange') {
      this.dispatchEvent('message', '<small style="color:gray">' + type + '</small>');
    } else if (type === 'onicecandidate') {
      if (msg) {
        this.dispatchEvent('ice', JSON.stringify(msg));
      }
      this.dispatchEvent('message', '<small style="color:lightgray">Ice Candidate Produced</small>');
    } else if (type === 'ondatachannel') {
      this.dispatchEvent('message', '<small style="color:blue">Data Channel Ready [Recipient]</small>');
      this.channel = freedom['core.rtcdatachannel'](msg.channel);
      this.channel.on(this.onDataChannelMsg.bind(this));
    } else {
      this.dispatchEvent('message', JSON.stringify({type: type, msg: msg}));
    }
  }.bind(this));
}
940898
public State signal(String name) throws UnknownTransitionException {
        Transition t = find(name);
        if (t != null) {
            return t.process(this);
        }
        throw new UnknownTransitionException(name);
    }
341787
function dispatchCallback(name, args) {
                    if(_initialized) {
                        var callback = _currentPreparedOptions.callbacks[name];
                        var extensionOnName = name;
                        var ext;

                        if(extensionOnName.substr(0, 2) === "on")
                            extensionOnName = extensionOnName.substr(2, 1).toLowerCase() + extensionOnName.substr(3);

                        if(type(callback) == TYPES.f)
                            callback.call(_base, args);

                        FRAMEWORK.each(_extensions, function() {
                            ext = this;
                            if(type(ext.on) == TYPES.f)
                                ext.on(extensionOnName, args);
                        });
                    }
                    else if(!_destroyed)
                        _callbacksInitQeueue.push({ n : name, a : args });
                }
156877
function StubServer(app) {
  _classCallCheck(this, StubServer);

  this._app = app;

  app.createServer = this.createServer_.bind(this, app.createServer || function () { throw new Error("no registered transport provider"); });
}
822989
function debug(name) {
  function disabled(){}
  disabled.enabled = false;

  var match = skips.some(function(re){
    return re.test(name);
  });

  if (match) return disabled;

  match = names.some(function(re){
    return re.test(name);
  });

  if (!match) return disabled;

  function logger(msg) {
    msg = (msg instanceof Error) ? (msg.stack || msg.message) : msg;
    Function.prototype.apply.call(logger.log, this, arguments);
  }

  logger.log = exports.log;
  logger.enabled = true;

  return logger;
}
7663
function callback (prefix, name, message) {
      if (!message) {
        return false;
      }
      count++;
      var msg  = errMsg(prefix, name, message);
      switch(action) {
      case 'show':
        console.log(msg);
        break;
      case 'hide':
        break;
      case 'throw':
      case 'copy':
        throw new Error(msg);
      }
      return true;
    }
702915
public void dispatchMethod (String name, Object[] arguments)
    {
        // first check the cache
        Method method = _mcache.get(name);
        if (method == null) {
            // if we haven't already determined this method doesn't exist, try
            // to resolve it
            if (!_mcache.containsKey(name)) {
                _mcache.put(name, method = resolveMethod(name, arguments));
            }
        }
        if (method != null) {
            try {
                method.invoke(_target, arguments);
            } catch (Exception e) {
                log.warning("Failed to dispatch event callback " +
                    name + "(" + StringUtil.toString(arguments) + ").", e);
            }
        }
    }
1028108
function Lock(named) {
  if (!(this instanceof Lock))
    return Lock.create(named);

  this.named = named === true;

  this.jobs = [];
  this.busy = false;
  this.destroyed = false;

  this.map = new Map();
  this.current = null;

  this.unlocker = this.unlock.bind(this);
}
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
912468
function(name, action, context) {
        if (!name || !action) {
            return;
        }
        var handlers = this.__handlers__ || (this.__handlers__={});
        if (!handlers[name]) {
            handlers[name] = [];
        }
        else {
            if (this.has(name, action)) {
                return;
            }
        }
        var handler = new Handler(action, context || this);
        handlers[name].push(handler);

        return this;
    }