/* (non-Javadoc)
@see javax.jms.Session#unsubscribe(java.lang.String)
196017
@Override
	public void unsubscribe(String subscriptionName) throws JMSException
    {
    	externalAccessLock.readLock().lock();
    	try
		{
	        checkNotClosed();
	        if (StringTools.isEmpty(subscriptionName))
	            throw new FFMQException("Empty subscription name","INVALID_SUBSCRIPTION_NAME");
	
	        // Remove remaining subscriptions on all topics
	        engine.unsubscribe(connection.getClientID(), subscriptionName);
		}
    	finally
    	{
    		externalAccessLock.readLock().unlock();
    	}
    }
948068
protected static <E extends Event> void unsubscribeEvent(Class<E> eventClass, final Listener<E> listener) {
        getEventBus().unsubscribe(eventClass, listener);
    }
1083393
def unsubscribe(self, ssid, max_msgs=0):
        
        if self.is_closed:
            raise ErrConnectionClosed

        sub = None
        try:
            sub = self._subs[ssid]
        except KeyError:
            # Already unsubscribed.
            return

        # In case subscription has already received enough messages
        # then announce to the server that we are unsubscribing and
        # remove the callback locally too.
        if max_msgs == 0 or sub.received >= max_msgs:
            self._subs.pop(ssid, None)
            self._remove_subscription(sub)

        # We will send these for all subs when we reconnect anyway,
        # so that we can suppress here.
        if not self.is_reconnecting:
            yield self.auto_unsubscribe(ssid, max_msgs)
195291
protected void unsubscribe( String id, MessagingContext ctx ) throws IOException {

		if( ! canProceed())
			return;

		Set<MessagingContext> sub = this.routingContext.subscriptions.get( id );
		if( sub != null ) {
			sub.remove( ctx );
			if( sub.isEmpty())
				this.routingContext.subscriptions.remove( id );
		}
	}
249257
public void unsubscribeAll(EventPublisher source) {
	log.debug("[unsubscribeAll] Cleaning all listeners for {}", source.getClass().getName());
	GenericEventDispatcher<?> dispatcher = dispatchers.get(source);
	if (dispatcher != null) {
	    dispatcher.removeListeners();
	}

    }
990026
def unsubscribe(self, event):
        """"""
        # TODO: Automatic Unsubscription
        uuids = event.data

        if not isinstance(uuids, list):
            uuids = [uuids]

        result = []

        for uuid in uuids:
            if uuid in self.subscriptions:
                self.subscriptions[uuid].pop(event.client.uuid)

                if len(self.subscriptions[uuid]) == 0:
                    del (self.subscriptions[uuid])

                result.append(uuid)

        result = {
            'component': 'hfos.events.objectmanager',
            'action': 'unsubscribe',
            'data': {
                'uuid': result, 'success': True
            }
        }

        self._respond(None, result, event)
1359642
public static void unRegister(Class<? extends Event> eventClass, Subscriber subscriber) {
        CopyOnWriteArraySet<Subscriber> set = SUBSCRIBER_MAP.get(eventClass);
        if (set != null) {
            set.remove(subscriber);
            if (LOGGER.isDebugEnabled()) {
                LOGGER.debug("UnRegister subscriber: {} of event: {}.", subscriber, eventClass);
            }
        }
    }
662421
def handle_unsubscribe(client, data)
      topic = @engine.unsubscribe_client_from_topic(client, data[0])

      trigger(:unsubscribe, client, topic.uri)
    end
297084
@Override
	public int unregisterTopicSession(String topic, Session session) {
		if (isInconsistenceContext(topic, session)) {
			return 0;
		}
		logger.debug("'{}' unsubscribe to '{}'", session.getId(), topic);
		if (Constants.Topic.ALL.equals(topic)) {
			for (Map.Entry<String, Collection<Session>> entry : map.entrySet()) {
				Collection<Session> sessions = entry.getValue();
				removeSessionToSessions(session, sessions);
				if (sessions.isEmpty()) {
					map.remove(entry.getKey());
				}
			}
		} else {
			Collection<Session> sessions = map.get(topic);
			removeSessionToSessions(session, sessions);
			if (sessions==null || sessions.isEmpty()) {
				map.remove(topic);
			}
		}
		return getNumberSubscribers(topic);
	}
749406
public void unsubscribeResourceForAll(CmsObject cms, CmsResource resource) throws CmsException {

        if (!isEnabled()) {
            throw new CmsRuntimeException(Messages.get().container(Messages.ERR_SUBSCRIPTION_MANAGER_DISABLED_0));
        }
        m_securityManager.unsubscribeResourceForAll(cms.getRequestContext(), getPoolName(), resource);
    }
619858
def unsubscribe(&blk)
      pres = connection.presence_stanza('to'=>jid.bare, 'type' => 'unsubscribe')
      connection.send_stanza pres, &blk
    end
959368
def unsubscribe(self, channel, *channels):
        
        conn = self._pool_or_conn
        return conn.execute_pubsub(b'UNSUBSCRIBE', channel, *channels)
1222583
public void unsubscribe() {
        if (this.dispatcher != null) {
            throw new IllegalStateException(
                    "Subscriptions that belong to a dispatcher cannot respond to unsubscribe directly.");
        } else if (this.incoming == null) {
            throw new IllegalStateException("This subscription is inactive.");
        }

        if (isDraining()) { // No op while draining
            return;
        }

        this.connection.unsubscribe(this, -1);
    }
750043
async def unsubscribe(self, topic: str):
        

        req_msg = {
            'type': 'unsubscribe',
            'topic': topic,
            'response': True
        }

        await self._conn.send_message(req_msg)
1162836
func (c *ChromeTarget) Unsubscribe(method string) {
	c.eventLock.Lock()
	delete(c.eventDispatcher, method)
	c.eventLock.Unlock()
}
708892
function unsubscribe() {
    var _this = this;
    var dataBindings = Reflect.getMetadata(constance_1.STATEX_DATA_BINDINGS_KEY, this);
    if (dataBindings != undefined) {
        var subscriptions = dataBindings.subscriptions || [];
        subscriptions.forEach(function (item) { return item.target === _this && item.subscription != undefined && item.subscription.unsubscribe(); });
        dataBindings.subscriptions = subscriptions.filter(function (item) { return item.target !== _this; });
        Reflect.defineMetadata(constance_1.STATEX_DATA_BINDINGS_KEY, dataBindings, this);
    }
}
995791
public void stop(boolean unsubscribe) throws MessagingException {
        try {
            if (unsubscribe) {
                m_jmsManager.unsubscribeAllDurable();
            }
            m_jmsManager.close();
            m_jmsManager = null;
            m_connected = false;
        } catch (MessagingException me) {
            logger.error("Messaging Exception encountered attempting to stop "
                    + "Messaging Client: " + m_clientId
                    + ". Exception message: " + me.getMessage(), me);
            throw me;
        }
    }