Unsubscribe to each subscription
@param {Object} [subscriptions] An optional hash of subscription to remove
480995
function(subscriptions){
      subscriptions = subscriptions || this.subscriptions;
      if (!subscriptions || _.isEmpty(subscriptions)) return;
      _.each(subscriptions, function(subscription, channel){
        if (_.isString(subscription)) {
          subscription = this[subscription];
        }
        Backbone.Mediator.unsubscribe(channel, subscription.$once || subscription, this);
      }, this);
    }
905780
function(client, subscriptions, backlog, channel, callback, done_callback) {
    if ( addToBacklog(client, backlog, unsubscribeBrowser, [client, subscriptions, backlog, channel, callback, done_callback]) ) return;
    if (subscriptions[channel]===undefined)
        return;
    subscriptions[channel].splice(subscriptions[channel].indexOf(callback), 1);
    if (subscriptions[channel].length===0) {
        delete subscriptions[channel];
        client.unsubscribe(channel, {onSuccess : function() {
            // If there is a done_callback defined, execute it
            if (done_callback!==undefined) done_callback();
        }});
    }
}
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;
    });
  }
}
1312466
public void unsubscribe() {
        final long id = Thread.currentThread().getId();
        queues.remove(id);
        if (subscriberIdentifiers != null) {
            for (Iterator<Entry<Object, Long>> iterator = subscriberIdentifiers.entrySet().iterator(); iterator.hasNext(); ) {
                if (id == iterator.next().getValue()) {
                    iterator.remove();
                    break;
                }
            }
        }
    }
377598
def unsubscribe_from_data(
        self,
        subscriber: Callable[[bytes], bool],
    ) -> None:
        
        self._data_subscribers.remove(subscriber)
976967
private void terminateSubscriptions(IoSession session, String heapUri, Subscription.CloseReason reason) {
        terminateSubscriptions(session, heapStates.get(heapUri), heapUri, reason);
    }
237577
function unsubscribe(topicArn) {

        // if not subscribed then return now
        if (!subscriptions[topicArn]) {
            debug('Not subscribed to ' + topicArn);
            return Promise.resolve();
        }

        return new Promise(function(resolve, reject) {
            const params = { SubscriptionArn: topicArn };
            config.sns.unsubscribe(params, function (err) {
                debug('Unsubscribe from ' + topicArn + (err ? ' failed: ' + err.message : 'succeeded'));
                if (err) return reject(err);
                delete subscriptions[topicArn];
                resolve();
            });
        });
    }
561471
public void setSubscriptions(java.util.Collection<Subscription> subscriptions) {
        if (subscriptions == null) {
            this.subscriptions = null;
            return;
        }

        this.subscriptions = new com.amazonaws.internal.SdkInternalList<Subscription>(subscriptions);
    }
1094397
function unsubscribe(subscription) {
    const index = exports.subscriptions.indexOf(subscription);
    if (index === -1)
        return;
    subscription.stop();
    // asteroid.unsubscribe(subscription.id) // v2
    exports.subscriptions.splice(index, 1); // remove from collection
    log_1.logger.info(`[${subscription.id}] Unsubscribed`);
}
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
164606
def unsubscribe(self):
        """"""
        self.subscription = None
        self._user_assignment.clear()
        self.assignment.clear()
        self.subscribed_pattern = None
331406
function(subscriptions){
      if (subscriptions) _.extend(this.subscriptions || {}, subscriptions);
      subscriptions = subscriptions || this.subscriptions;
      if (!subscriptions || _.isEmpty(subscriptions)) return;
      // Just to be sure we don't set duplicate
      this.unsetSubscriptions(subscriptions);

      _.each(subscriptions, function(subscription, channel){
        var once;
        if (subscription.$once) {
          subscription = subscription.$once;
          once = true;
        }
        if (_.isString(subscription)) {
          subscription = this[subscription];
        }
        Backbone.Mediator.subscribe(channel, subscription, this, once);
      }, this);
    }
339642
function unsubscribe() {
    if (channel.tag) {
      qLog.info(`Unsubscribing from queue ${channelName} with tag ${channel.tag}`);
      return channel.cancel(channel.tag);
    }
    return Promise.resolve();
  }
166687
def remove(self, event, subscriber):
        
        subs = self._subscribers
        if event not in subs:
            raise ValueError('No subscribers: %r' % event)
        subs[event].remove(subscriber)
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'
989936
async def _unsubscribe(self, channels, is_mask):
        """"""
        vanished = []
        if channels:
            for channel in channels:
                key = channel, is_mask
                self._channels.remove(key)
                self._plugin._subscriptions[key].remove(self._queue)
                if not self._plugin._subscriptions[key]:  # we were last sub?
                    vanished.append(channel)
                    del self._plugin._subscriptions[key]
        else:
            while self._channels:
                channel, is_mask = key = self._channels.pop()
                self._plugin._subscriptions[key].remove(self._queue)
                if not self._plugin._subscriptions[key]:
                    vanished.append(channel)
                    del self._plugin._subscriptions[key]
        if vanished:
            await getattr(self._sub, 'punsubscribe' if is_mask else 'unsubscribe')(vanished)
158556
def unsubscribe_all(self, callback=False):
        """"""
        futures = ((f, r) for f, r in self._requests.items()
                   if isinstance(r, Subscribe)
                   and f not in self._pending_unsubscribes)
        if futures:
            for future, request in futures:
                if callback:
                    log.warn("Unsubscribing from %s", request.path)
                    cothread.Callback(self.unsubscribe, future)
                else:
                    self.unsubscribe(future)