Unregister an object from the default registry. Equivalent to
{@code DefaultMonitorRegistry.getInstance().unregister(Monitors.newObjectMonitor(id, obj))}.

@param obj Previously registered using {@code Monitors.registerObject(id, obj)}
761276
public static void unregisterObject(String id, Object obj) {
    DefaultMonitorRegistry.getInstance().unregister(newObjectMonitor(id, obj));
  }
141071
public void unregister(final Object listener) {
		for (Class clazz = listener.getClass(); clazz != null; clazz = clazz.getSuperclass()) {
			this.handlersByEventType.removeAll(clazz);
		}
	}
590406
public synchronized void unregister() throws Exception {
        if (mbeanName == null) {
            throw new Exception("Agent not registered");
        }
        logger.info("Unregistering JMX agent " + mbeanName);
        ManagementFactory.getPlatformMBeanServer().unregisterMBean(mbeanName);
        logger.info("JMX agent " + mbeanName + " unregistered");
    }
1188835
@DeleteMapping(path = "/instances/{id}")
    public Mono<ResponseEntity<Void>> unregister(@PathVariable String id) {
        LOGGER.debug("Unregister instance with ID '{}'", id);
        return registry.deregister(InstanceId.of(id))
                       .map(v -> ResponseEntity.noContent().<Void>build())
                       .defaultIfEmpty(ResponseEntity.notFound().build());
    }
509951
public <T extends DObject> T registerObject (T object)
    {
        if (_dobjThread != null && !isDispatchThread()) {
            log.warning("Registering DObject on non-dobject thread",
                        "class", object.getClass().getName(), new Exception());
        }

        int oid = getNextOid();

        // initialize this object
        object.setOid(oid);
        object.setManager(this);

        // set the default access controller if a controller hasn't already been specified
        if (object.getAccessController() == null) {
            object.setAccessController(_defaultController);
        }

        // insert it into the table
        _objects.put(oid, object);

//         log.info("Registered object", "obj", object);

        return object;
    }
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);
      
   }
386344
public static void unregisterCacheObject(String cacheManagerName, String name, boolean stats) {
        synchronized (mBeanServer) {
            ObjectName objectName = calculateObjectName(cacheManagerName, name, stats);
            Set<ObjectName> registeredObjectNames = mBeanServer.queryNames(objectName, null);
            if (isRegistered(cacheManagerName, name, stats)) {
                //should just be one
                for (ObjectName registeredObjectName : registeredObjectNames) {
                    try {
                        mBeanServer.unregisterMBean(registeredObjectName);
                    } catch (InstanceNotFoundException e) {
                        // it can happen that the instance that we want to unregister isn't found. So lets ignore it
                        // https://github.com/hazelcast/hazelcast/issues/11055
                        ignore(e);
                    } catch (Exception e) {
                        throw new CacheException("Error unregistering object instance " + registeredObjectName
                                + ". Error was " + e.getMessage(), e);
                    }
                }
            }
        }
    }
656097
function unregister() {
    if (!applicationCurrent) {
        return;
    }
    applicationCurrent.stop();

    EVENTS.forEach(function (event) {
        process.removeListener(event, currentHandlers[event]);
    });

    applicationCurrent = null;
    currentHandlers = {};
}
775130
void removeHandler( Object handlerRegistration )
	{
		// Through object's interface implementation
		if( handlerRegistration instanceof DirectHandlerInfo )
		{
			DirectHandlerInfo info = (DirectHandlerInfo) handlerRegistration;
			info.source.removePropertyChangedHandler( info.registrationObject );
			return;
		}
		
		if( ! ( handlerRegistration instanceof HandlerInfo ) )
			return;
		
		HandlerInfo info = (HandlerInfo) handlerRegistration;
	
		HashMap<String, ArrayList<PropertyChangedHandler>> handlersMap = PlatformSpecificProvider.get().getObjectMetadata( info.source );
		if( handlersMap == null )
			return;
	
		ArrayList<PropertyChangedHandler> handlerList = handlersMap.get( info.propertyName );
		if( handlerList == null )
			return;
	
		handlerList.remove( info.handler );
	
		if( handlerList.isEmpty() )
			handlersMap.remove( info.propertyName );
	
		if( handlersMap.isEmpty() )
			PlatformSpecificProvider.get().setObjectMetadata( info.source, null );
		
		stats.statsRemovedRegistration( info );
	
		info.handler = null;
		info.propertyName = null;
		info.source = null;
	}
141948
public static boolean isObjectRegistered(String id, Object obj) {
    return DefaultMonitorRegistry.getInstance().isRegistered(newObjectMonitor(id, obj));
  }
405578
def unregister(self, handler):
        
        for handler_obj in self.handlers:
            registered = handler_obj.handler
            if handler is registered:
                self.handlers.remove(handler_obj)
                return True
        raise ValueError('This handler is not registered!')
1058066
public void unregisterMBean(final ObjectName name) throws JMException {
    if ((beanServer != null) &&
        beanServer.isRegistered(name) &&
        registeredMBeanNames.remove(name)) {
      beanServer.unregisterMBean(name);
    }
  }
616399
public synchronized void unregister(final OStorage iStorage) {
		for (ODatabaseComplex<?> db : new HashSet<ODatabaseComplex<?>>(instances.keySet())) {
			if (db != null && db.getStorage() == iStorage) {
				db.close();
				instances.remove(db);
			}
		}
	}
625951
public static void recordDefaultAnnotationHandlerMappingInstance(Object obj) {
		if (debug) {
			System.out.println("SPRING_PLUGIN: Recording new instance of DefaultAnnotationHandlerMappingInstance");
		}
		defaultAnnotationHandlerMappingInstances.add(obj);
	}
1001513
public synchronized boolean unregisterObject(Object object) {
        int i = MiscUtil.indexOfInstance(registeredObjects, object);
        
        if (i > -1) {
            registeredObjects.remove(i);
            
            for (IRegisterEvent onRegister : onRegisterList) {
                onRegister.unregisterObject(object);
            }
            
            if (object instanceof IRegisterEvent) {
                onRegisterList.remove(object);
            }
            
            return true;
        }
        
        return false;
    }
304043
@Override
    protected <T> void unbind(LifecycleManager manager, Class<T> clazz, T object) throws ObjectNotAssociatedException {
        // cancel binding

        Binding binding = STORE.get(clazz);
        if (binding == null) {
            throw new ObjectNotAssociatedException();
        }
        if (!binding.containsKey(object)) {
            throw new ObjectNotAssociatedException();
        }
        binding.remove(object);

        // cancel tracking

        Tracking tracking = TRACK.get(manager);
        tracking.remove(clazz);
    }
96821
@Override
	public void unregisterIrObs(IREventObserver obs)
	{
		if (obs != null && irObserver == obs)
		{
			irObserver = null;
		}
	}