Unbind the {@link ExporterService}.
773660
@Unbind(id = "exporterServices")
    void unbindExporterService(ServiceReference<ExporterService> serviceReference) {
        LOG.debug(linkerName + " : Unbind the ExporterService " + exportersManager.getDeclarationBinder(serviceReference));
        synchronized (lock) {
            exportersManager.removeLinks(serviceReference);
            exportersManager.remove(serviceReference);
        }
    }
348183
def unbind(self):
        
        self.connected = False
        self.queue_manager.disconnect(self.connection)
        self.topic_manager.disconnect(self.connection)
842112
private void removeServiceListeners(String id) {
        final ServiceListener[] listeners = serviceListeners.remove(id);
        if (listeners != null)
            for (ServiceListener listener : listeners)
                if (listener != null) {
                    lock.readLock().lock();
                    try {
                        if (bundleContext != null)
                            bundleContext.removeServiceListener(listener);
                    } finally {
                        lock.readLock().unlock();
                    }
                }
    }
1065573
public static void unregister() {
    synchronized (monitor) {
      checkState(handler != null, "Zipkin exporter is not registered.");
      unregister(Tracing.getExportComponent().getSpanExporter());
      handler = null;
    }
  }
999257
protected void unsetSerializationService(ServiceReference<SerializationService> ref) {
        if (TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_WAS.isLoggable(Level.FINE)) {
            LoggingUtil.SESSION_LOGGER_WAS.logp(Level.FINE, methodClassName, "unsetSerializationService", "unsetting " + ref);
        }
        serializationServiceRef.unsetReference(ref);
    }
1052916
protected final void unregisterProducer( AbstractMessageProducer producerToRemove )
    {
        if (producersMap.remove(producerToRemove.getId()) == null)
            log.warn("Unknown producer : "+producerToRemove);
    }
1327896
private void unmapDataProviderFromAllTriggers(final DP dataProvider) {
        if (dataProvider != null) {
            for (final List<DP> mappedDataProviders : triggersToDataProviders.values()) {
                mappedDataProviders.remove(dataProvider);
            }
        }
    }
1306801
public void remove(final Binding b) {
        if (!disposedInd) {
            boolean unsubscribe = false;
            if (bindings == null) {
                return;
            }
            unsubscribe = bindings.remove(b);
            if (unsubscribe) {
                // if we removed successfully we then need to call dispose on it
                b.dispose();
            }
        }
    }
1248406
public void remove(IConverter converter, Object sourceObject,
			TypeReference<?> destinationType) {
		convertedObjects.remove(new ConvertedObjectsKey(converter,
				sourceObject, destinationType));
	}
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;
        }
    }
790461
def __unset_binding(self, dependency, service, reference):
        # type: (Any, Any, ServiceReference) -> None
        
        # Call the component back
        self.__safe_field_callback(
            dependency.get_field(),
            constants.IPOPO_CALLBACK_UNBIND_FIELD,
            service,
            reference,
        )

        self.safe_callback(constants.IPOPO_CALLBACK_UNBIND, service, reference)

        # Update the injected field
        setattr(self.instance, dependency.get_field(), dependency.get_value())

        # Unget the service
        self.bundle_context.unget_service(reference)
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()
1020204
function removeBindingImport (binding) {
  const path = binding.path
  if (path.parentPath.isImportDeclaration() &&
      // Remove the entire Import if this is the only imported binding.
      path.parentPath.node.specifiers.length === 1) {
    path.parentPath.remove()
  } else {
    path.remove()
  }
}
1260089
function() {
    this._unbindModel();
    this.map.bind('change:view_bounds_sw',  this._changeBounds, this);
    this.map.bind('change:view_bounds_ne',  this._changeBounds, this);
    this.map.bind('change:zoom',            this._setZoom, this);
    this.map.bind('change:scrollwheel',     this._setScrollWheel, this);
    this.map.bind('change:keyboard',        this._setKeyboard, this);
    this.map.bind('change:center',          this._setCenter, this);
    this.map.bind('change:attribution',     this.setAttribution, this);
  }
603545
public void removeFactory(FileSetProvider factory) {
		if (logger.isLoggable(Level.FINER)) {
			logger.finer("Removing factory: " + factory);
		}
		filters.remove(factory);
	}
619445
public void remove(final CompositeBinding b) {
        if (!disposedInd) {
            boolean unsubscribe = false;
            if (compBindings == null) {
                return;
            }
            unsubscribe = compBindings.remove(b);
            if (unsubscribe) {
                // if we removed successfully we then need to call dispose on it
                b.dispose();
            }
        }
    }
517904
function unbind(el, type, fn, capt) {
	el.removeEventListener(type.slice(2), fn, capt);
}