Unbinds the coordination router socket from all interfaces
@return {object} masterElector
322623
function unbind () {
    _inbox.unbindSync(`tcp://0.0.0.0:${node.settings.coordinationPort}`)
    _inbox.removeListener('message', _onInboxMessage)
    return resolver
  }
632981
function deregisterInteractionHandler(fnHandler) {
			var i,
				oParentDOM = this.$parent.get(0),
				oBlockLayerDOM = this.$blockLayer.get(0);

			if (oParentDOM) {
				for (i = 0; i < aPreventedEvents.length; i++) {
				// Remove event listeners with "useCapture" settings
					oParentDOM.removeEventListener(aPreventedEvents[i], fnHandler, {
						capture: true,
						passive: false
					});
				}
			}
			if (this._aSuppressHandler) {
				for (i = 0; i < this._aSuppressHandler.length; i++) {
					// this part should be done even no DOMRef exists
					EventTriggerHook.release(this._aSuppressHandler[i]);
				}
			}
			if (oBlockLayerDOM) {
				this.$blockLayer.unbind('keydown', fnHandler);
			}
		}
885757
function() {
      if (!this._unbound) {
        log.unbind && console.log('[%s] asyncUnbindAll', this.localName);
        this._unbindAllJob = this.job(this._unbindAllJob, this.unbindAll, 0);
      }
    }
348183
def unbind(self):
        
        self.connected = False
        self.queue_manager.disconnect(self.connection)
        self.topic_manager.disconnect(self.connection)
59167
function unbind (vm, key) {
  var source = vm._wilddogSources && vm._wilddogSources[key]
  if (!source) {
    throw new Error(
      'VueWild: unbind failed: "' + key + '" is not bound to ' +
      'a Wilddog reference.'
    )
  }
  var listeners = vm._wilddogListeners[key]
  for (var event in listeners) {
    source.off(event, listeners[event])
  }
  vm[key] = null
  vm.$wilddogRefs[key] = null
  vm._wilddogSources[key] = null
  vm._wilddogListeners[key] = null
}
1015918
def unbind(self):
        
        args_dispatchers = set()
        f = self._wf()
        if f is not None:
            for ad_list in self.bound_to.values():
                args_dispatchers.update(ad_list)
                for argspec, dispatcher in ad_list:
                    dispatcher.unbind(self.f, argspec)
            del f.__dict__['__mnd__']
        self.bound_to = {}
        return args_dispatchers
1158516
function disconnect(socket) {
  if (socket.namespace.name === '') return socket.disconnect();
  socket.packet({type:'disconnect'});
  socket.manager.onLeave(socket, socket.namespace.name);
  socket.$emit('disconnect', 'booted');
}
33339
function removeConnection(conn) {

  this.emit('disconnect');

  conn.removeAllListeners('input');
  conn.removeAllListeners('output');

  // clean channel subscriptions
  if(conn.client.pubsub) {
    // must slice channels ref
    this._pubsub.unsubscribe(
      conn, conn.client.pubsub.channels.slice(0));
  }

  // clean pattern subscriptions
  // client.pubsub can be null after
  // removing channel subscriptions
  if(conn.client.pubsub) {
    // must slice patterns ref
    this._pubsub.punsubscribe(
      conn, conn.client.pubsub.patterns.slice(0));
  }

  var ind = this._conn.indexOf(conn);
  // remove the connection reference
  // the server disconnect listener is once
  // so we should always have a valid
  // index into the array
  this._conn.splice(ind, 1);
}
1268639
function(configArg) {

        // When specified, the `messages` option should trigger the complete
        // removal of any previously-bound message handlers.
        if (socket && configArg.messages) {
          _(config.messages).forEach(function(handler, name, messageHandlers) {
            socket.removeListener('message-' + name);
            cloak._off('message-' + name, handler);
          });
        }

        _.extend(config, configArg);

        if (socket) {
          cloak._applyConfig(config);
        }
      }
987537
function () {
            /*  determine parameters  */
            var params = $cs.params("unsocket", arguments, {
                id: { pos: 0, req: true }
            });

            /*  remove  parameters from component  */
            if (typeof this.__sockets[params.id] === "undefined")
                throw _cs.exception("unsocket", "socket not found");

            /*  remove corresponding property  */
            var name = this.__sockets[params.id];
            $cs(this).property(name, null);

            /*  remove socket information  */
            delete this.__sockets[params.id];
            return;
        }
953944
function disconnectController($scope, $rootScope, $window) {

    /**
     * Default settings
     */
    const DEFAULT_HEADING = "Browsersync";
    const DEFAULT_MESSAGE = "Disconnected";

    $scope._disconnected = false;

    /**
     * Default state
     * @type {{visible: boolean, status: string, heading: string, text: string}}
     */
    $scope.ui = {
        visible: false,
        heading: DEFAULT_HEADING,
        message: DEFAULT_MESSAGE
    };

    /**
     * @type {{connection: Function, disconnect: Function}}
     */
    $scope.socketEvents = {
        connection: function () {
            if ($scope._disconnected) {
                $window.location.reload(true);
            }
            $scope.ui.visible = false;
            $scope.$digest();
        },
        disconnect: function () {
            $scope._disconnected = true;
            $scope.ui.visible = true;
            $scope.$digest();
        }
    };

    $rootScope.$on("ui:connection", $scope.socketEvents.connection);
    $rootScope.$on("ui:disconnect", $scope.socketEvents.disconnect);
}
806782
function unbindEvent(element, type, handler) {
    const events = safeEvent(element, type);
    const items = events.get(handler);

    if (!items) {
        return;
    }

    forgetHandler(element, type, handler);

    util.forEach(items, func => {
        if ('removeEventListener' in element) {
            element.removeEventListener(type, func);
        } else if ('detachEvent' in element) {
            element.detachEvent(`on${type}`, func);
        }
    });
}
666538
def _unbind(self, rmq_server=None):
        
        try:
            self.connections[rmq_server].close()
        except AttributeError:
            pass

        self.connections[rmq_server] = None
        self.channels[rmq_server] = None
318462
function() {
        // The last component to be unmounted uninstalls the event listener.
        if (components.length == 0) {
            document.removeEventListener(EVENT_TYPE, dispatchEvent);
        }
        components.splice(components.indexOf(this), 1);
    }
202846
function unbindEventListeners(instanceData) {
		for (var type in instanceData.eventHandlers) {
			if (instanceData.eventHandlers.hasOwnProperty(type)) {
				$(instanceData.element).off(type, instanceData.eventHandlers[type]);
			}
		}

		instanceData.eventHandlers = {};
	}
1370427
function removeBindings() {
      for (var i = 0; i < this._c.length; i++) {
        this.unbind(this._c[i].children);
      }
    }
1216935
function () {
                this.$assert(838, this._listenersStopped !== true);
                this._listenersStopped = true;
                var bindings = this._bindings;
                if (bindings) {
                    // remove binding
                    for (var index = 0, bind; bind = bindings[index]; index++) {
                        // remove the recursive listener
                        this.__json.removeListener(bind.inside, bind.to, bind.callback, bind.recursive);
                    }
                }
            }