unregisters the events for the ResourceBuilder
@param resourceBuilder an instance of ResourceBuilder
514374
private void unregisterEventsForResourceBuilder(ResourceBuilderModel resourceBuilder) {
        resourceBuilder.announceEvents().stream()
                .map(eventSubscribers::get)
                .filter(Objects::nonNull)
                .forEach(list -> list.remove(resourceBuilder));
    }
190366
private void removeResourceMethods(Object theProvider, Class<?> clazz, Collection<String> resourceNames) throws ConfigurationException {
		for (Method m : ReflectionUtil.getDeclaredMethods(clazz)) {
			BaseMethodBinding<?> foundMethodBinding = BaseMethodBinding.bindMethod(m, getFhirContext(), theProvider);
			if (foundMethodBinding == null) {
				continue; // not a bound method
			}
			if (foundMethodBinding instanceof ConformanceMethodBinding) {
				myServerConformanceMethod = null;
				continue;
			}
			String resourceName = foundMethodBinding.getResourceName();
			if (!resourceNames.contains(resourceName)) {
				resourceNames.add(resourceName);
			}
		}
	}
715099
private void registerResourceIDsForResourceBuilder(ResourceBuilderModel resourceBuilder) {
        List<? extends ResourceModel> resources = resourceBuilder.announceResources();
        if(resources == null) return;
        resources.stream()
                .map(this::getRegisteredListForResource)
                .forEach(list -> list.add(resourceBuilder));
    }
546797
public void unregisterServiceHandler(String name) {
        Map<String, Object> serviceHandlers = getServiceHandlers(false);
        if (serviceHandlers != null) {
            serviceHandlers.remove(name);
        }
    }
767743
@Override
	public final void unregister( ObjectName name ) throws JMSException
	{
	    log.debug("Unregistering object "+name);
	    try
	    {
	        this.mBeanServer.unregisterMBean(name);
	    }
	    catch (Exception e)
	    {
	        throw new FFMQException("Cannot unregister MBean","JMX_ERROR",e);
	    }
	}
976910
public void removeType(String resourceType) {

        m_searchObject.removeType(resourceType);
        m_searchObjectChanged = true;
        ValueChangeEvent.fire(this, m_searchObject);
    }
749406
public void unsubscribeResourceForAll(CmsObject cms, CmsResource resource) throws CmsException {

        if (!isEnabled()) {
            throw new CmsRuntimeException(Messages.get().container(Messages.ERR_SUBSCRIPTION_MANAGER_DISABLED_0));
        }
        m_securityManager.unsubscribeResourceForAll(cms.getRequestContext(), getPoolName(), resource);
    }
1349896
public void unregisterService() {

		try {
			if( this.serviceReg != null ) {
				this.logger.finer( "Running in an OSGi environment. Trying to unregister a MBean for the messaging." );
				this.serviceReg.unregister();
				this.logger.finer( "Running in an OSGi environment. The MBean was unregistered." );
			}

		} catch( Exception e ) {
			this.logger.severe( "A MBean could not be unregistered for the messaging." );
			Utils.logException( this.logger, e );

		} finally {
			this.serviceReg = null;
		}
	}
454633
@Override
  public void unregister(Monitor<?> monitor) {
    try {
      List<MonitorMBean> beans = MonitorMBean.createMBeans(name, monitor, mapper);
      for (MonitorMBean bean : beans) {
        try {
          mBeanServer.unregisterMBean(bean.getObjectName());
          locks.remove(bean.getObjectName());
        } catch (InstanceNotFoundException ignored) {
          // ignore errors attempting to unregister a non-registered monitor
          // a common error is to unregister twice
        }
      }
      monitors.remove(monitor.getConfig());
      updatePending.set(true);
    } catch (Exception e) {
      LOG.warn("Unable to un-register Monitor:" + monitor.getConfig(), e);
    }
  }
259006
private void registerEventsForResourceBuilder(ResourceBuilderModel resourceBuilder) {
        List<? extends EventModel<?>> events = resourceBuilder.announceEvents();
        if(events == null) return;
        events.stream()
                .filter(event -> event.getAllInformations() != null)
                .flatMap(event -> event.getAllInformations().stream())
                .map(this::getRegisteredListForEvent)
                .forEach(list -> list.add(resourceBuilder));
    }
1250204
public void unregister() {
        // clean up the connections by first closing them
        for (WebSocketConnection conn : conns) {
            conn.close();
        }
        conns.clear();
        // clean up the listeners by first stopping them
        for (IWebSocketDataListener listener : listeners) {
            listener.stop();
        }
        listeners.clear();
    }
16647
public void unregister(EventDefinition eventDefinition, IEventListener eventListener) {
        if (eventDefinition.getType() == EventDefinition.TYPE_POST) {
            unregister(listenersPost, eventDefinition, eventListener);
        } else {
            unregister(listeners, eventDefinition, eventListener);
        }
    }
248429
void unregister(ResourceMonitorImpl monitorImpl)
   {
      Set<Entry<WatchKey, ResourceMonitorImpl>> entrySet = keys.entrySet();
      Iterator<Entry<WatchKey, ResourceMonitorImpl>> iterator = entrySet.iterator();
      while (iterator.hasNext())
      {
         Entry<WatchKey, ResourceMonitorImpl> next = iterator.next();
         if (next.getValue() == monitorImpl)
         {
            next.getKey().cancel();
            iterator.remove();
         }
      }
   }
1018757
private void stop() {
        //unregister and free all resources;
        if (updateTask != null)
            updateTask.cancel();
        for (GenericStatsProducer producer : producers) {
            producer.genericStats.destroy();
            ProducerRegistryFactory.getProducerRegistryInstance().unregisterProducer(producer);
        }
        producers.clear();
    }
669016
public static void unregisterDao(ConnectionSource connectionSource,
			Class<?> clazz) {

		Dao<?, ?> dao = DaoManager.lookupDao(connectionSource, clazz);
		if (dao != null) {
			DaoManager.unregisterDao(connectionSource, dao);
		}

	}
417323
public void unregisterWorkManager(WorkManager wm)
   {
      if (wm != null)
      {
         if (wm.getName() == null || wm.getName().trim().equals(""))
            throw new IllegalArgumentException("The name of WorkManager is invalid: " + wm);

         if (trace)
            log.tracef("Unregistering WorkManager: %s", wm);

         if (workmanagers.keySet().contains(wm.getName()))
         {
            workmanagers.remove(wm.getName());

            // Clear any events
            if (wm instanceof DistributedWorkManager)
            {
               WorkManagerEventQueue wmeq = WorkManagerEventQueue.getInstance();
               List<WorkManagerEvent> events = wmeq.getEvents(wm.getName());
               events.clear();
            }
         }
      }
   }
754817
public <EventT> boolean unregister(Object key, Class<EventT> eventClass) {
    LOG.debug("[{}] Unregistering {} for {}", logPrefix, key, eventClass);
    return listeners.remove(eventClass, key);
  }