Unbind this queue from an exchange

 @param [BunnyMock::Exchange,String] exchange Exchange to unbind from
 @param [Hash] opts Binding properties

 @option opts [String] :routing_key Custom routing key

 @api public
345470
def unbind(exchange, opts = {})
      check_queue_deleted!

      if exchange.respond_to?(:remove_route)

        # we can do the unbinding ourselves
        exchange.remove_route opts.fetch(:routing_key, @name), self
      else

        # we need the channel to lookup the exchange
        @channel.queue_unbind self, opts.fetch(:routing_key, @name), exchange
      end
    end
1114428
def remove_from_queue(self, index):
        
        # TODO: what do these parameters actually do?
        updid = '0'
        objid = 'Q:0/' + str(index + 1)
        self.avTransport.RemoveTrackFromQueue([
            ('InstanceID', 0),
            ('ObjectID', objid),
            ('UpdateID', updid),
        ])
836903
def unbind(self, dependency, svc, svc_ref):
        # type: (Any, Any, ServiceReference) -> None
        
        with self._lock:
            # Invalidate first (if needed)
            self.check_lifecycle()

            # Call unbind() and remove the injection
            self.__unset_binding(dependency, svc, svc_ref)

            # Try a new configuration
            if self.update_bindings():
                self.check_lifecycle()
322623
function unbind () {
    _inbox.unbindSync(`tcp://0.0.0.0:${node.settings.coordinationPort}`)
    _inbox.removeListener('message', _onInboxMessage)
    return resolver
  }
971512
def _on_qosok(self, qosok_frame):
        
        for name, args in self._exchanges.items():
            self._channel.exchange_declare(
                exchange=name,
                exchange_type=args["type"],
                durable=args["durable"],
                auto_delete=args["auto_delete"],
                arguments=args["arguments"],
                passive=config.conf["passive_declares"],
                callback=self._on_exchange_declareok,
            )
        for name, args in self._queues.items():
            self._channel.queue_declare(
                queue=name,
                durable=args["durable"],
                auto_delete=args["auto_delete"],
                exclusive=args["exclusive"],
                arguments=args["arguments"],
                passive=config.conf["passive_declares"],
                callback=self._on_queue_declareok,
            )
1207892
public static boolean unBindPort(Session session, int localPort) {
		try {
			session.delPortForwardingL(localPort);
			return true;
		} catch (JSchException e) {
			throw new JschRuntimeException(e);
		}
	}
223994
public AmqpChannel unbindQueue(String queue, String exchange, String routingKey, AmqpArguments arguments) {
        Object[] args = {0, queue, exchange, routingKey, arguments};
        WrappedByteBuffer bodyArg = null;
        HashMap<String, Object> headersArg = null;

        String methodName = "unbindQueue";
        String methodId = "50" + "50";
        AmqpMethod amqpMethod = MethodLookup.LookupMethod(methodId);
        Object[] methodArguments = {this, amqpMethod, this.id, args, bodyArg, headersArg};
        asyncClient.enqueueAction(methodName, "channelWrite", methodArguments, null, null);
        return this;
    }
436762
def remove_custom_binding(self, key_name, needs_prefix=False):
        
        k = (needs_prefix, key_name)

        if k in self.custom_bindings:
            self.custom_key_bindings.remove(self.custom_bindings[k].handler)
            del self.custom_bindings[k]
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
736526
def unbind(topic, func):
    
    if topic in _receivers:
        receivers = _receivers[topic]
        for i in range(len(receivers)-1, -1, -1):
            nice, f = receivers[i]
            if (callable(func) and f['func'] == func) or (f['func_name'] == func):
                del receivers[i]
                return
1364113
def bind(receiver)
      unbind if bound?
      
      @receiver = receiver
      configs.each_pair do |key, config|
        value = store.has_key?(key) ? store.delete(key) : config.default
        config.set(receiver, value)
      end
      
      self
    end
1072500
def exchange_bind_to_queue(self, type, exchange_name, routing_key, queue):
        
        self._channel.exchange_declare(exchange=exchange_name,
                                       exchange_type=type)
        self._channel.queue_bind(queue=queue,
                                 exchange=exchange_name,
                                 routing_key=routing_key)
707261
def queue_bind(self, queue, exchange, routing_key, arguments=None):
        """"""
        return self.channel.queue_bind(queue=queue,
                                       exchange=exchange,
                                       routing_key=routing_key,
                                       arguments=arguments)
1065378
def delete_api_key(key, request_options = {})
      client.delete(Protocol.index_key_uri(name, key), :write, request_options)
    end
391570
def _unbind(cls, boundname):
        

        try:
            fs = CPE2_3_FS(boundname)
        except:
            # CPE name is not formatted string
            try:
                uri = CPE2_3_URI(boundname)
            except:
                # CPE name is not URI but WFN
                return CPE2_3_WFN(boundname)
            else:
                return CPE2_3_WFN(uri.as_wfn())
        else:
            return CPE2_3_WFN(fs.as_wfn())
1105717
public void removeXmitQueuePoint(SIBUuid8 meUuid)
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "removeXmitQueuePoint", meUuid);

    if (_xmitQueuePoints != null)
    {
      synchronized(_xmitQueuePoints)
      {
        _xmitQueuePoints.remove(meUuid);
      }
    }

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "removeXmitQueuePoint");
  }
1168854
public function unbindExchange($destinationName, $sourceName, $routingKey = '')
    {
        // WARNING: only amqp 1.6.0 and above supports exchange unbinding
        if (phpversion('amqp') <= '1.4.0') {
            return;
        }

        $exchange = $this->produceExchangeInstance($destinationName);

        $exchange->unbind($sourceName, $routingKey);
    }