Unsubscribe from the queue (stop calling the message handler)
@public
339642
function unsubscribe() {
    if (channel.tag) {
      qLog.info(`Unsubscribing from queue ${channelName} with tag ${channel.tag}`);
      return channel.cancel(channel.tag);
    }
    return Promise.resolve();
  }
1027898
function unsubscribe() {
  console.log('Unsubscribing client ' + clientId + ' from topic: ' + topics.subscribe);
  if (isSubscribed === true) {
    client.unsubscribe(topics.subscribe, function () {
      console.log('sucessfully unsubscribed');
      isSubscribed = false;
    });
  }
}
1374137
def unsubscribe(self, socket_id, channel):
        """"""
        con = self._get_connection(socket_id, create=False)
        if con is not None:
            con.subscriptions.discard(channel)
        try:
            self.subscriptions[channel].discard(socket_id)
        except KeyError:
            pass
293778
def unsubscribe(self, connection):
        """"""
        self._subscribed_connections.discard(connection)
        self._last_unsubscribe_time = current_time()
137613
def stop(self):
        '''
        
        '''
        log.info('Stopping te kafka listener class')
        self.consumer.unsubscribe()
        self.consumer.close()
1229950
function() {
      return new Promise((resolve) => {
        log.debug(`Destroy called on queue ${this.name} - ${connection.name} (${this.channel.getMessageCount()} messages pending)`);
        this.on('destroyed', () => {
          this.subscriptions = [];
          resolve();
        }).once();
        this.handle('destroy');
      });
    }
1255562
def remove(self):
        
        self.logger.debug('Remove subscription from server...')

        data = {
            'command': 'unsubscribe',
            'identifier': self._identifier_string()
        }

        self.connection.send(data)
        self.state = 'unsubscribed'
1146560
def _stop(self):
        
        # Running flag down
        self.running = False

        # Unregister the service listener
        self.__context.remove_service_listener(self)

        # Clean up handler factories usages
        with self.__instances_lock:
            for svc_ref in self._handlers_refs:
                self.__context.unget_service(svc_ref)

            self._handlers.clear()
            self._handlers_refs.clear()
137737
def stop(self):
        
        msg = cr.Message()
        msg.type = cr.STOP
        self.send_message(msg)
428693
def stop(self) -> None:
        
        if not self._running:
            return

        self._running = False
        self._receiving_queue.put_nowait((TRANSPARENT_EVENT, None))
        self._internal_queue.put_nowait((TRANSPARENT_EVENT, None))
719090
function dispose() {
            if (!this.disposed) {
                if (this.removeListener) {
                    this.removeListener.call(this);
                    this.removeListener = void 0;
                }

                if (this.targetUrl && this.target || this.removeDispose) {
                    try {
                        if (this.targetContainer) {
                            this.targetContainer.removeChild(this.target);
                        }
                        else {
                            document.body.removeChild(this.target);
                        }
                    }
                    catch(ex) {
                        /* istanbul ignore next  */
                        PostMessageUtilities.log("Error while trying to remove the iframe from the container", "ERROR", "PostMessageChannel");
                    }
                }

                // Remove load handler if needed
                _removeTimer.call(this);

                // Remove timer if needed
                _removeLoadedHandler.call(this);

                this.messageQueue.length = 0;
                this.messageQueue = void 0;
                this.channel = void 0;
                this.onready = void 0;
                this.disposed = true;
            }
        }
667598
def unsubscribe_from_hub(self, event, callback):
        
        return self._hub("unsubscribe", event, callback, github.GithubObject.NotSet)
474780
def unsubscribe_all(self):
        """"""
        for channel in self.list_all():
            channel.ensure_stopped()
        self.connect_api.stop_notifications()
551140
function unsubscribe (channels) {
    pullAll(_subscribedChannels, channels)
    if (_socket) channels.forEach(channel => _socket.unsubscribe(channel))
    return connection
  }
115702
def unsubscribe(channel, _json_data)
      log_debug "#{self.class} runs 'unsubscribe' method with  #{channel}"
      return unless channel.present?
      forget_channel(channel)
      delete_server_subscribers(channel)
    end
983079
function unsubscribe() {
    console.log(' > ', 'init', ['xmlrpc_bin://' + thisHost + ':2031', '']);
    rpcClient.methodCall('init', ['xmlrpc_bin://' + thisHost + ':2031', ''], function (err, res) {
        console.log(err, res);

        process.exit(0);
    });
    setTimeout(function () {
        console.log('force quit');
        process.exit(1);
    }, 1000);
}
1020912
function() {
		var bindingState = this._bindingState;
		var options = this._options;

		// Turn off the parent listener
		if (bindingState.parent === true && this._parentToChild === true) {
			bindingState.parent = false;
			turnOffListeningAndUpdate(options.parent, options.child, this._updateChild, options.queue);
		}

		// Turn off the child listener
		if (bindingState.child === true && this._childToParent === true) {
			bindingState.child = false;
			turnOffListeningAndUpdate(options.child, options.parent, this._updateParent, options.queue);
		}
	}