Remove bean associated with this wrapper instance. <p>
This method is part of the EJBLocalObject interface.
420744
public void remove() throws RemoveException, javax.ejb.EJBException
    {
        try {
            container.removeBean(this);
        } catch (java.rmi.RemoteException e) {
            FFDCFilter.processException(e, CLASS_NAME + ".remove", "132", this);
            throw new EJBException(e);
        }
    }
1187152
public void remove()
  {
    if (tc.isEntryEnabled()) 
      SibTr.entry(tc, "remove");
    
    if (anycastIHIterator != null)
    {  
      anycastIHIterator.remove();
    }
    
    if (tc.isEntryEnabled()) 
      SibTr.exit(tc, "remove");
  }
702520
@Override
	public void destroy() {
		try {
			ContextClassLoaderUtils.doWithClassLoader(jasperClassLoader,
					new Callable<Void>() {

						@Override
						public Void call() throws Exception {
							jasperServlet.destroy();
							return null;
						}

					});
			//CHECKSTYLE:OFF
		} catch (Exception ignore) {
			// ignored as it should never happen
			LOG.error("Ignored exception", ignore);
		}
		//CHECKSTYLE:ON
	}
1237669
public void unregisterJsonValueProcessor( Class beanClass, String key ) {
      if( beanClass != null && key != null ) {
         beanKeyMap.remove( beanClass, key );
      }
   }
238705
protected boolean destroy(String name) {
		BeanLifecycleWrapper wrapper = this.cache.remove(name);
		if (wrapper != null) {
			Lock lock = this.locks.get(wrapper.getName()).writeLock();
			lock.lock();
			try {
				wrapper.destroy();
			}
			finally {
				lock.unlock();
			}
			this.errors.remove(name);
			return true;
		}
		return false;
	}
74161
public void destroy() {
        for (Entry<String, Runnable> entry : destructionCallbacks.entrySet()) {
            try {
                entry.getValue().run();
            } catch (Throwable t) {
                log.error("Error during destruction callback for bean " + entry.getKey(), t);
            }
        }
        
        beans.clear();
        destructionCallbacks.clear();
    }
662949
public static void clearBeanProperty(final Object bean, final String name) {
		Validate.notNull(bean, "Bean required");
		Validate.notEmpty(name, "Not empty property name required");

		final String methodName = new StringBuilder("set")
				.append(name.substring(0, 1).toUpperCase())
				.append(name.substring(1)).toString();
		for (Method method : bean.getClass().getMethods()) {
			if (method.getName().equals(methodName)) {
				try {
					method.invoke(bean, (Object) null);
					return;
				} catch (Exception exc) {
					throw new RuntimeException("Failed to clear property: "
							+ name);
				}
			}
		}
		throw new RuntimeException("Setter of property not found: " + name);
	}
1350611
public void remove(Class<?> clazz) {
		ClassMetadata metadata = get(clazz);
		metadataByClass.remove(clazz);
		metadataByKind.remove(metadata.getKind());
	}
555664
public void destroySelf(){
        if(mPager == null || mPager.getAdapter() == null){
            return;
        }
        InfinitePagerAdapter wrapper = (InfinitePagerAdapter)mPager.getAdapter();
        PagerAdapter adapter = wrapper.getRealAdapter();
        if(adapter!=null){
            adapter.unregisterDataSetObserver(dataChangeObserver);
        }
        removeAllViews();
    }
978458
public synchronized void destroy()
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled())
            Tr.event(tc, "Destroying home ", new Object[] { this, j2eeName });

        if (!enabled) {
            return;
        }

        // F743-1751 - Explicitly destroy singletons since they are not pooled.
        if (ivSingletonBeanO != null)
        {
            try
            {
                ivSingletonBeanO.destroy();
            } catch (Throwable ex)
            {
                FFDCFilter.processException(ex, CLASS_NAME + ".destroy", "809", this);
            }
        }

        if (beanPool != null) {
            beanPool.destroy();
        }

        enabled = false;

        if (pmiBean != null) {
            container.pmiFactory.removePmiModule(pmiBean); // d146239.14
        }
    }
369110
public void removeListener(BaseListener listener, boolean bFreeListener)
    {
        if (m_listener != null)
        {
            if (m_listener == listener)
            {
                m_listener = (FieldListener)listener.getNextListener();
                listener.unlink(bFreeListener);     // remove theBehavior from the linked list
            }
            else
                m_listener.removeListener(listener, bFreeListener);
        } // Remember to free the listener after removing it!
    }
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();
            }
        }
    }
1227500
function() {
        /**
         * We have to override this method because the event pane destroy
         * deletes the mapObject reference before removing this layer from
         * the map.
         */
        if (this.map) {
            this.setGMapVisibility(false);
            var cache = OpenLayers.Layer.Google.cache[this.map.id];
            if (cache && cache.count <= 1) {
                this.removeGMapElements();
            }            
        }
        OpenLayers.Layer.EventPane.prototype.destroy.apply(this, arguments);
    }
1348546
public void removeBOSHClientResponseListener(
            final BOSHClientResponseListener listener) {
        if (listener == null) {
            throw(new IllegalArgumentException(NULL_LISTENER));
        }
        responseListeners.remove(listener);
    }
1211953
public static void unregisterJMXBean(ServletContext servletContext, String resourceType, String mBeanPrefix) {

		try {

			MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();

			if (mbs != null) {

				ObjectName jawrConfigMgrObjName = JmxUtils.getMBeanObjectName(servletContext, resourceType,
						mBeanPrefix);

				// register the jawrApplicationConfigManager if it's not already
				// done
				ObjectName appJawrMgrObjectName = JmxUtils.getAppJawrConfigMBeanObjectName(servletContext, mBeanPrefix);
				if (mbs.isRegistered(appJawrMgrObjectName)) {
					mbs.unregisterMBean(appJawrMgrObjectName);
				}

				if (mbs.isRegistered(jawrConfigMgrObjName)) {
					mbs.unregisterMBean(jawrConfigMgrObjName);
				}
			}

		} catch (InstanceNotFoundException | MBeanRegistrationException e) {
			LOGGER.error("Unable to unregister the Jawr MBean for resource type '" + resourceType + "'", e);
		}
	}
1211207
private void poll()
    {
        final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();

        // Note: A ReferenceQueue is thread safe and may be accessed concurrently
        //       from multiple threads. However, a BeanO should only be destroyed
        //       on a single thread, which is fine since its key will be returned
        //       from poll() only once.

        BeanO bean = null;
        int removeCount = 0;
        Reference<? extends EJSWrapperBase> ref;
        while ((ref = ivRefQueue.poll()) != null)
        {
            synchronized (ivCache)
            {
                bean = ivCache.remove(ref);
            }
            ++removeCount;

            if (isTraceOn && tc.isDebugEnabled())
                Tr.debug(tc, "poll : removed (" + ref + ", " + bean + ")");

            // It is possible a bean was removed during clear, and yet the
            // wrapper is still on the reference queue, so handle null.
            if (bean != null) {
                bean.destroy();
            }
        }
        if (isTraceOn && tc.isDebugEnabled())
            Tr.debug(tc, "poll : size = " + ivCache.size() + ", removed = " + removeCount);
    }
1270244
public boolean destroy(Contextual bean)
    {
        FacesContext facesContext = FacesContext.getCurrentInstance();
        List<String> activeFlowMapKeys = getFlowScopeBeanHolder().getActiveFlowMapKeys(facesContext);
        for (String flowMapKey : activeFlowMapKeys)
        {
            ContextualStorage storage = getContextualStorage(false, flowMapKey);
            if (storage == null)
            {
                //return false;
                continue;
            }
            ContextualInstanceInfo<?> contextualInstanceInfo = storage.getStorage().get(storage.getBeanKey(bean));

            if (contextualInstanceInfo == null)
            {
                //return false;
                continue;
            }

            bean.destroy(contextualInstanceInfo.getContextualInstance(), contextualInstanceInfo.getCreationalContext());
            return true;
        }
        return false;
    }