Calls the iPOPO unbind method
9137
def __unbind_call(self, still_valid):
        
        with self._lock:
            if self.__timer is not None:
                # Timeout expired, we're not valid anymore
                self.__timer = None
                self.__still_valid = still_valid
                self._ipopo_instance.unbind(
                    self, self.__timer_args[0], self.__timer_args[1]
                )
1251612
public static function unregisterInstance(): void
    {
        if (!self::$unregistering && self::$client !== null) {
            self::$unregistering = true;

            if ((self::$client->preparedToSendBuffer ?: '') !== '') {
                self::$client->sendBuffer .= self::$client->preparedToSendBuffer;
            }

            try {
                self::$client->sendBuffer .= self::$client->protocol->getKeepAlive();
                self::$client->protocol->flush();
            } catch (\Throwable $e) {
            }

            // TODO MUST TEST, IT WAS REMOVED FROM FUNCTION
            // BECAUSE IT SIMPLY LOOKS LIKE THE LINES BEFORE
            // ADDED AN IF TO CHECK THE CHANNEL In CASE OF
            //
            if (isset(self::$client->protocol->handler->channel) &&
                false === strpos(get_class(self::getClient()->protocol->handler->channel), '/EmptyChannel/')) {
                try {
                    self::$client->protocol->keepAlive();
                } catch (\Throwable $e) {
                    // silently discard exceptions when unregistering
                }
            }

            self::$client = null;
            self::$instance = null;
            self::$instanceOptionsKey = null;
            self::$unregistering = false;
        }
    }
517904
function unbind(el, type, fn, capt) {
	el.removeEventListener(type.slice(2), fn, capt);
}
1284369
function _unbindDragHandlers(_el) {
            if (!_el._katavorioDrag) return;
            if (prune || orphan) {
                _el._katavorioDrag.off(STOP, _pruneOrOrphan);
            }
            if (!prune && !orphan && revert) {
                _el._katavorioDrag.off(REVERT, _revalidate);
                _el._katavorioDrag.setRevert(null);
            }
        }
1002335
function unbind () {
    if (!_bound) return
    _sub.close()
    _pub.close()
    _subPort = null
    _pubPort = null
    _bound = false
    stoptHeartbeats()
  }
3950
private base_response unset_request(nitro_service service, options option, String args[])  throws Exception
	{
		String sessionid = service.get_sessionid();
		String request = unset_string(service, sessionid, option, args);
		return post_data(service,request);
	}
442237
def unbind
      if bound?
        configs.each_pair do |key, config|
          store[key] = config.get(receiver)
        end
        @receiver = nil
      end
      self
    end
1118360
public Unbind unbind(byte[] b) {
        Unbind req = new Unbind();
        assignHeader(req, b);
        return req;
    }
1246643
def unbind(self, instance_id: str, binding_id: str, details: UnbindDetails):
        
        
        # Find the instance
        instance = self._backend.find(instance_id)
        
        # Find the binding
        binding = self._backend.find(binding_id, instance)
        if not binding.isProvisioned():
            # The binding does not exist
            raise ErrBindingDoesNotExist()
        
        # Delete the binding
        self._backend.unbind(binding)
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
630206
@Unbind
    public void unbindFactory(Factory factory) {
        try {
            lock.lock();
            InstanceDeclaration declaration = getDeclarationByFactory(factory);
            if (declaration != null) {
                LOGGER.info("Disposing instance created by");
                declaration.dispose();
                declarations.remove(declaration);
            }
        } finally {
            lock.unlock();
        }
    }
16398
public void unbind(T service, Map<String, Object> props) {
    synchronized (serviceMap) {
      serviceMap.remove(ServiceUtil.getComparableForServiceRanking(props));
      updateSortedServices();
    }
  }
656302
@Unbind
    public synchronized void unbindDialect(IDialect dialect) {
        LOGGER.debug("Binding a new dialect {}, processors: {}", dialect.getPrefix(),
                dialect.getProcessors());
        if (this.dialects.remove(dialect)) {
            configure();
            for (Template template : getTemplates()) {
                ((ThymeLeafTemplateImplementation) template).updateEngine(engine);
            }
        }
    }
360722
@Override
    public boolean onUnbind(Intent intent) {
        LogManager.i(TAG, "unbinding so destroying self");
        this.stopForeground(true);
        this.stopSelf();
        return false;
    }
917749
def unbind(self, callback: typing.Union[typing.Callable, AbstractFilter]):
        
        for record in self._registered:
            if record.callback == callback:
                self._registered.remove(record)
146369
@NonNull @UiThread
  public static Unbinder bind(@NonNull Object target, @NonNull View source) {
    Class<?> targetClass = target.getClass();
    if (debug) Log.d(TAG, "Looking up binding for " + targetClass.getName());
    Constructor<? extends Unbinder> constructor = findBindingConstructorForClass(targetClass);

    if (constructor == null) {
      return Unbinder.EMPTY;
    }

    //noinspection TryWithIdenticalCatches Resolves to API 19+ only type.
    try {
      return constructor.newInstance(target, source);
    } catch (IllegalAccessException e) {
      throw new RuntimeException("Unable to invoke " + constructor, e);
    } catch (InstantiationException e) {
      throw new RuntimeException("Unable to invoke " + constructor, e);
    } catch (InvocationTargetException e) {
      Throwable cause = e.getCause();
      if (cause instanceof RuntimeException) {
        throw (RuntimeException) cause;
      }
      if (cause instanceof Error) {
        throw (Error) cause;
      }
      throw new RuntimeException("Unable to create binding instance.", cause);
    }
  }
1094890
public void unbindService() {
        Log.v(TAG, "Trying to unbind the service");
        Context context = this.context.get();
        if (isBound && context != null) {
            context.unbindService(this);
            isBound = false;
        }
    }