Fire a notification for a collection of beans that have been deleted.

@param beans deleted beans
488683
public final void fireDelete(List<Bean> beans) {
        ConfigChanges changes = new ConfigChanges();
        for (Bean bean : beans) {
            changes.add(ConfigChange.deleted(bean));
        }
        fire(changes);
    }
45919
public void setInventoryDeletions(java.util.Collection<InventoryDeletionStatusItem> inventoryDeletions) {
        if (inventoryDeletions == null) {
            this.inventoryDeletions = null;
            return;
        }

        this.inventoryDeletions = new com.amazonaws.internal.SdkInternalList<InventoryDeletionStatusItem>(inventoryDeletions);
    }
227807
protected void fireEditingStopped() {
        // Guaranteed to return a non-null array
        Object[] listeners = listenerList.getListenerList();
        // Process the listeners last to first, notifying
        // those that are interested in this event
        for (int i = listeners.length-2; i>=0; i-=2) {
            if (listeners[i]==CellEditorListener.class) {
                ((CellEditorListener)listeners[i+1]).editingStopped(new ChangeEvent(this));
            }
        }
    }
436458
public void fireRemoveAppenderEvent(final Category logger,
                                        final Appender appender) {
       if (repo instanceof Hierarchy) {
           ((Hierarchy) repo).fireRemoveAppenderEvent(logger, appender);
       }
    }
992328
void firePropertyChildRemoved(TreeNodeRemovedEvent event) {
		if (this.nodeListeners != null) {
			for (final TreeNodeListener listener : this.nodeListeners) {
				if (listener != null) {
					listener.treeNodeChildRemoved(event);
				}
			}
		}
		final N parentNode = getParentNode();
		if (parentNode != null) {
			parentNode.firePropertyChildRemoved(event);
		}
	}
253333
protected final void fireServiceRevoked(BeanContextServiceRevokedEvent event)
	{
		Object listeners[];
		synchronized (bcsListeners)
		{
			listeners = bcsListeners.toArray();
		}
		for (int i = 0; i < listeners.length; i++)
		{
			BeanContextServicesListener l = (BeanContextServicesListener) listeners[i];
			l.serviceRevoked(event);
		}
	}
133132
public void setBeans(Collection<?> beans)
    {
        if (!CollectionUtils.isEmpty(beans))
        {
            for (Object bean : beans)
            {
                register(bean);
            }
        }
    }
890121
@Override
    public synchronized BeanContext stop() {
        if (terminating.compareAndSet(false, true)) {
            if (LOG.isDebugEnabled()) {
                LOG.debug("Stopping BeanContext");
            }
            publishEvent(new ShutdownEvent(this));

            // need to sort registered singletons so that beans with that require other beans appear first
            List<BeanRegistration> objects = topologicalSort(singletonObjects.values());

            Set<Integer> processed = new HashSet<>();
            for (BeanRegistration beanRegistration : objects) {
                BeanDefinition def = beanRegistration.beanDefinition;
                Object bean = beanRegistration.bean;
                int sysId = System.identityHashCode(bean);
                if (processed.contains(sysId)) {
                    continue;
                }

                if (LOG_LIFECYCLE.isDebugEnabled()) {
                    LOG_LIFECYCLE.debug("Destroying bean [{}] with identifier [{}]", bean, beanRegistration.identifier);
                }

                processed.add(sysId);
                if (def instanceof DisposableBeanDefinition) {
                    try {
                        //noinspection unchecked
                        ((DisposableBeanDefinition) def).dispose(this, bean);
                    } catch (Throwable e) {
                        if (LOG.isErrorEnabled()) {
                            LOG.error("Error disposing of bean registration [" + def.getName() + "]: " + e.getMessage(), e);
                        }
                    }
                }
                if (def instanceof Closeable) {
                    try {
                        ((Closeable) def).close();
                    } catch (Throwable e) {
                        if (LOG.isErrorEnabled()) {
                            LOG.error("Error disposing of bean registration [" + def.getName() + "]: " + e.getMessage(), e);
                        }
                    }
                }
                if (bean instanceof LifeCycle) {
                    ((LifeCycle) bean).stop();
                }
            }

            terminating.set(false);
            running.set(false);
            ClassLoadingReporter.finish();
        }
        return this;
    }
225499
private void fireResultRemoved(Result child, Result parent) {
    if(LOG.isDebugging()) {
      LOG.debug("Result removed: " + child + " <- " + parent);
    }
    for(int i = listenerList.size(); --i >= 0;) {
      listenerList.get(i).resultRemoved(child, parent);
    }
  }
1002415
private void destroySingletons() {
        if (log.isDebugEnabled()) {
            log.debug("Destroying singletons in " + this);
        }

        int failedDestroyes = 0;
        for (BeanRule beanRule : beanRuleRegistry.getIdBasedBeanRules()) {
            failedDestroyes += doDestroySingleton(beanRule);
        }
        for (Set<BeanRule> beanRuleSet : beanRuleRegistry.getTypeBasedBeanRules()) {
            for (BeanRule beanRule : beanRuleSet) {
                failedDestroyes += doDestroySingleton(beanRule);
            }
        }
        for (BeanRule beanRule : beanRuleRegistry.getConfigurableBeanRules()) {
            failedDestroyes += doDestroySingleton(beanRule);
        }
        if (failedDestroyes > 0) {
            log.warn("Singletons has not been destroyed cleanly (Failure Count: " + failedDestroyes + ")");
        } else {
            log.debug("Destroyed all cached singletons in " + this);
        }
    }
840630
protected void fireKNNsRemoved(DBIDs removals, DBIDs updates) {
    KNNChangeEvent e = new KNNChangeEvent(this, KNNChangeEvent.Type.DELETE, removals, updates);
    Object[] listeners = listenerList.getListenerList();
    for(int i = listeners.length - 2; i >= 0; i -= 2) {
      if(listeners[i] == KNNListener.class) {
        ((KNNListener) listeners[i + 1]).kNNsChanged(e);
      }
    }
  }
1249930
public final ConfigChanges deleted(String schemaName, Collection<String> instanceIds) {
        ConfigChanges changes = new ConfigChanges();
        for (String instanceId : instanceIds) {
            BeanId id = BeanId.create(instanceId, schemaName);
            Optional<Bean> before = beanManager.getEager(id);
            if (!before.isPresent()) {
                throw Events.CFG304_BEAN_DOESNT_EXIST(id);
            }
            Bean bean = before.get();
            schemaManager.setSchema(Arrays.asList(bean));
            changes.add(ConfigChange.deleted(bean));
        }
        return changes;
    }
795944
public void cleanup(){

        synchronized (mBeanServer) {

            for (ObjectName beanName : beansNames)
                try {
                    mBeanServer.unregisterMBean(beanName);
                } catch (InstanceNotFoundException ignored) {
                    // Bean previously been unregistered
                } catch (MBeanRegistrationException e) {
                    log.warn("Exception thrown while trying to clean up registered MBeans", e);
                }

        }

    }
1124926
@Override
    public void notifyDestroyed(Integer id)
    {
        enabled = false;
        boxs.clear();
        cacheColls.clear();
        cacheRect.clear();
    }
187772
private void fireMemberRemoved(MemberId exMember) {
        GL.debug(GL.CLUSTER_LOGGER_NAME, "Firing member removed for: {}", exMember);
        for (MembershipEventListener listener : membershipEventListeners) {
            try {
                listener.memberRemoved(exMember);
            } catch (Throwable e) {
                GL.error(GL.CLUSTER_LOGGER_NAME, "Error in member removed event {}", e);
            }
        }
    }
342080
public void setDeletedFaces(java.util.Collection<String> deletedFaces) {
        if (deletedFaces == null) {
            this.deletedFaces = null;
            return;
        }

        this.deletedFaces = new java.util.ArrayList<String>(deletedFaces);
    }
865925
public void fireChange() {
        if (getNotification() && listeners != null) {
            EventObject event = new EventObject(this);
            for (int i = 0; i < listeners.size(); i++) {
                listeners.get(i).stateChanged(event);
            }
        }
    }