THIS METHOD WILL ME MOVED/RENAMED, DO NOT USE.

@param registry the registry to unregister from.
@param provider the provider to unregister.
@param category the category to unregister from.
762182
public static <T> void deregisterProvider(final ServiceRegistry registry, final IIOServiceProvider provider, final Class<T> category) {
        // http://www.ibm.com/developerworks/java/library/j-jtp04298.html
        registry.deregisterServiceProvider(category.cast(provider), category);
    }
502831
public void registerProvider(Object provider) {
		if (provider != null) {
			Collection<Object> providerList = new ArrayList<>(1);
			providerList.add(provider);
			registerProviders(providerList);
		}
	}
813748
static void unregister(Object value) {
        if (value != null) {
            Map<Object, Object> m = getRegistry();
            if (m != null) {
                m.remove(value);
                if (m.isEmpty()) {
                    REGISTRY.remove();
                }
            }
        }
    }
1355875
@Deprecated
    public final void remove(MeterRegistry registry) {
        for (; ; ) {
            if (childrenGuard.compareAndSet(false, true)) {
                try {
                    Map<MeterRegistry, T> newChildren = new IdentityHashMap<>(children);
                    newChildren.remove(registry);
                    this.children = newChildren;
                    break;
                } finally {
                    childrenGuard.set(false);
                }
            }
        }
    }
437239
@Override
    public void deregisterFactories(ChannelFactoryProvider provider) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
            Tr.event(tc, "Removing factory provider; " + provider.getClass().getName());
        }
        for (Entry<String, Class<? extends ChannelFactory>> entry : provider.getTypes().entrySet()) {
            this.providers.remove(entry.getKey());
            deregisterFactory(entry.getKey());
        }
        this.activatedProviders.remove(provider);
    }
1148794
public static void unregister(String ID) {
        displayNameCache.remove(new CaseInsensitiveString(ID));
        registry.remove(ID);
    }
1247294
def unregister_provider(self, provider):
        
        self._unregistering_providers.add(provider)
        remaining_providers = self._providers - self._unregistering_providers
        if not remaining_providers:
            _log.debug('unregistering from queueconsumer %s', self)
            self.queue_consumer.unregister_provider(self)
            _log.debug('unregistered from queueconsumer %s', self)
            self._unregistered_from_queue_consumer.send(True)

        _log.debug('waiting for unregister from queue consumer %s', self)
        self._unregistered_from_queue_consumer.wait()
        super(RpcConsumer, self).unregister_provider(provider)
843145
public void unregisterDeclaration(T declaration) {
        ServiceRegistration registration;
        synchronized (declarationsRegistered) {
            registration = declarationsRegistered.remove(declaration);
            if (registration == null) {
                throw new IllegalStateException("The given Declaration has never been registered"
                        + "or have already been unregistered.");
            }
        }
        registration.unregister();
    }
658659
public void deregister(CacheEntryListenerConfiguration<K, V> configuration) {
    requireNonNull(configuration);
    dispatchQueues.keySet().removeIf(registration ->
        configuration.equals(registration.getConfiguration()));
  }
1221061
@SuppressWarnings({ "unchecked", "rawtypes" })
  public <T> void removeRegistraion(String subjectName, SubjectObserver<T> subjectObserver)
   {
      Subject subject = (Subject)this.registry.get(subjectName);
      
      if(subject == null)
         return;
      
      subject.remove(subjectObserver);
      
   }
927203
public static <T extends Tag, V> void unregister(Class<T> tag, Class<V> type) {
        tagToConverter.remove(tag);
        typeToConverter.remove(type);
    }
991486
public void unregisterServiceInstance(String serviceName, String instanceId, final RegistrationCallback cb, Object context){
        ProtocolHeader header = new ProtocolHeader();
        header.setType(ProtocolType.UnregisterServiceInstance);

        UnregisterServiceInstanceProtocol p = new UnregisterServiceInstanceProtocol(serviceName, instanceId);
        ProtocolCallback pcb = new ProtocolCallback(){

            @Override
            public void call(boolean result, Response response,
                    ErrorCode error, Object ctx) {
                cb.call(result, error, ctx);
            }

        };
        connection.submitCallbackRequest(header, p, pcb, context);
    }
1298299
@Override
    public void unregister(final Context context, final Callback<Void> callback) {
        new AsyncTask<Void, Void, Exception>() {
            @Override
            protected Exception doInBackground(Void... params) {

                try {

                    if ((deviceToken == null) || (deviceToken.trim().equals(""))) {
                        throw new IllegalStateException(DEVICE_ALREADY_UNREGISTERED);
                    }

                    if (instanceId == null) {
                        instanceId = firebaseInstanceIdProvider.get(context);
                    }
                    String token = Tasks.await(instanceId.getInstanceId(), 30, TimeUnit.SECONDS).getToken();

                    FirebaseMessaging firebaseMessaging = firebaseMessagingProvider.get(context);

                    for (String catgory : categories) {
                        firebaseMessaging.unsubscribeFromTopic(catgory);
                    }

                    //Unsubscribe to generic topic
                    firebaseMessaging.unsubscribeFromTopic(variantId);

                    instanceId.deleteInstanceId();

                    HttpProvider provider = httpProviderProvider.get(deviceRegistryURL, TIMEOUT);
                    setPasswordAuthentication(variantId, secret, provider);

                    try {
                        provider.delete(deviceToken);
                        deviceToken = "";
                        removeSavedPostData(context.getApplicationContext());
                        return null;
                    } catch (HttpException ex) {
                        return ex;
                    }

                } catch (Exception ex) {
                    return ex;
                }

            }

            @SuppressWarnings("unchecked")
            @Override
            protected void onPostExecute(Exception result) {
                if (result == null) {
                    callback.onSuccess(null);
                } else {
                    callback.onFailure(result);
                }
            }

        }.execute((Void) null);
    }
217661
@Managed
   @ManagedDescription("Reset all the statistics.")
   public static void resetAll(
      @ManagedDescription("The name of the category of the statistics") 
      @ManagedName("categoryName") String category)
   {
      StatisticsContext context = getContext(category);
      if (context != null)
      {
         context.reset();
      }
   }
891117
def delete_category(self, category):
        """"""
        # Remove mapping of metrics-to-category
        category_key = self._category_key(category)
        self.r.delete(category_key)

        # Remove category from Set
        self.r.srem(self._categories_key, category)
141071
public void unregister(final Object listener) {
		for (Class clazz = listener.getClass(); clazz != null; clazz = clazz.getSuperclass()) {
			this.handlersByEventType.removeAll(clazz);
		}
	}
1137915
@Autowired
    public void setRegistry(BridgeHeadTypeRegistry registry) {
        this.registry = registry;
        registry.register(this);
        Method[] methods = offerArray(Object.class.getMethods(), nearType.getMethods());
        for (Method method : methods) {
            if (logger.isTraceEnabled()) {
                logger.trace("Method: " + display(method) + ": in: " + display(nearType));
            }
            Binding binding = getBinding(method.getReturnType(), method.getName(), method.getParameterTypes());
            if (binding == null) {
                String message = "No binding found: " + display(nearType) + ": " + display(method);
                logger.warn(message);
                throw new UnsupportedOperationException(message);
            }
            if (logger.isTraceEnabled()) {
                logger.trace("Binding: " + display(binding));
            }
            methodMap.put(method, binding);
        }
    }