Remove the EJB identified by the given <code>Handle</code>. <p>

@param handle a <code>Handle</code> identifing the EJB to remove <p>

@exception RemoteException
@exception RemoveException
427751
public void remove(Handle handle)
                    throws RemoteException,
                    RemoveException
    {
        homeEnabled();

        final boolean isTraceOn = TraceComponent.isAnyTracingEnabled(); // d532639.2

        if (isTraceOn && tc.isEntryEnabled())
            Tr.entry(tc, "remove", handle);

        EJBObject ejb = handle.getEJBObject();
        ejb.remove();

        if (isTraceOn && tc.isEntryEnabled())
            Tr.exit(tc, "remove");
    }
1112638
@Override
  public void removeHandler(Handler handler)
  {
    synchronized (this) {
      ClassLoader loader = Thread.currentThread().getContextClassLoader();
      
      if (loader == null) {
        loader = _systemClassLoader;
      }

      for (int i = _loaders.size() - 1; i >= 0; i--) {
        WeakReference<ClassLoader> ref = _loaders.get(i);
        ClassLoader refLoader = ref.get();

        if (refLoader == null) {
          _loaders.remove(i);
        }

        if (isParentLoader(loader, refLoader)) {
          removeHandler(handler, refLoader);
        }
      }

      HandlerEntry ownHandlers = _ownHandlers.get();
      if (ownHandlers != null)
        ownHandlers.removeHandler(handler);
    }
  }
253256
public void removeHandlers() {
    Iterator<HandlerRegistration> it = registrations.iterator();
    while (it.hasNext()) {
      HandlerRegistration r = it.next();

      /*
       * must remove before we call removeHandler. Might have come from nested
       * ResettableEventBus
       */
      it.remove();

      r.removeHandler();
    }
  }
1159504
@Override
    public void destroy(Exception e) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            Tr.entry(tc, "destroy, vc=" + getVCHash());
        }

        // Clean up the read and write interfaces as well as the SSL engine.
        this.connected = false;
        cleanup();
        getVirtualConnection().getStateMap().remove(LINKCONFIG);
        if (this.syncConnectFailure) {
            // sync connect failure needs cleanup below us but not above
            // us on the connlink chain
            super.destroy();
        } else {
            // otherwise use the destroy that goes up the chain
            super.destroy(e);
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            Tr.exit(tc, "destroy");
        }
    }
697737
@SuppressWarnings("unchecked")
    private void delete(SoftHandle<K, V> n) {
        if (n.tree == null) {
            throw new IllegalArgumentException("Invalid handle!");
        }

        /*
         * Delete from belonging list. Care must be taken as the tree reference
         * is valid only if the node is the first in the list.
         */
        TreeNode<K, V> tree = n.tree;

        if (tree.cHead != n) {
            /*
             * Not first in list. Each case, remove and leave as ghost element.
             */
            if (n.next != null) {
                n.next.prev = n.prev;
            }
            n.prev.next = n.next;
        } else {
            /*
             * First in list
             */
            SoftHandle<K, V> nNext = n.next;
            tree.cHead = nNext;
            if (nNext != null) {
                /*
                 * More elements exists, remove and leave as ghost element.
                 * Update new first element to point to correct tree.
                 */
                nNext.prev = null;
                nNext.tree = tree;
            } else {
                /*
                 * No more elements, sift.
                 */
                sift(tree);

                /*
                 * If still no elements, remove tree.
                 */
                if (tree.cHead == null) {
                    if (tree.parent instanceof TreeNode) {
                        TreeNode<K, V> p = (TreeNode<K, V>) tree.parent;
                        if (p.left == tree) {
                            p.left = null;
                        } else {
                            p.right = null;
                        }
                    } else {
                        delete((RootListNode<K, V>) tree.parent);
                    }
                }

            }
        }

        n.tree = null;
        n.prev = null;
        n.next = null;

        size--;
    }
733831
@Override
	public final void unlock(int handle) throws DataStoreException 
    {
        if (SAFE_MODE) checkHandle(handle);
        if (locks.flip(handle))
        {
            locks.flip(handle); // Restore state
            throw new DataStoreException("Handle was not locked : "+handle);
        }
    }
1176705
public void destroy(Exception e) {
        if (this.appCallback != null) {
            this.appCallback.destroy(e);
            this.appCallback = null;
        }
    }
739384
public void removeHandler() {

        clearShowing();
        if (m_overHandlerRegistration != null) {
            m_overHandlerRegistration.removeHandler();
            m_overHandlerRegistration = null;
        }
        m_target = null;
    }
94203
public void remove(Object primaryKey)
                    throws RemoteException,
                    RemoveException,
                    FinderException
    {
        // d141216 method rewritten to avoid calling preinvoke/postinvoke
        //         twice in code path (i.e. don't just call remove on the
        //         bean after it is activated).  With the re-write, the
        //         bean will be activated and removed in the same tran
        //         as defined by the tx attribute on home.remove().

        final boolean isTraceOn = TraceComponent.isAnyTracingEnabled(); // d532639.2

        if (isTraceOn && tc.isEntryEnabled())
            Tr.entry(tc, "remove(pk) : " + primaryKey);

        homeEnabled();

        // Session beans and MDBs cannot be removed using this method.
        // For session beans, the spec calls for throwing an exception
        // to indicate this (no PK). MDB section not specific, thus do
        // the same for consistency.

        if (statefulSessionHome || statelessSessionHome || messageDrivenHome)
        {
            throw new RemoveException();
        }

        BeanId beanId = ivEntityHelper.remove(this, primaryKey);

        if (isTraceOn && tc.isEntryEnabled())
            Tr.exit(tc, "remove(pk) : " + beanId);
    }
1325058
@Override
    public Handle getHandle() throws RemoteException
    {
        ComponentMetaDataAccessorImpl cmdAccessor = null; // p125735
        try {
            cmdAccessor = ComponentMetaDataAccessorImpl.getComponentMetaDataAccessor(); // p125735
            cmdAccessor.beginContext(bmd); // p125735
            return beanId.getHome().createHandle(beanId);
        } finally
        {
            if (cmdAccessor != null)
                cmdAccessor.endContext(); // p125735
        }
    }
266089
protected synchronized void unsetHandler(ServiceReference<Handler> handlerRef) {

        jaxwsInFlowClientSideGlobalHandlers.removeReference(handlerRef);
        jaxwsOutFlowClientSideGlobalHandlers.removeReference(handlerRef);
        jaxwsInFlowServerSideGlobalHandlers.removeReference(handlerRef);
        jaxwsOutFlowServerSideGlobalHandlers.removeReference(handlerRef);

        jaxrsInFlowClientSideGlobalHandlers.removeReference(handlerRef);
        jaxrsOutFlowClientSideGlobalHandlers.removeReference(handlerRef);
        jaxrsInFlowServerSideGlobalHandlers.removeReference(handlerRef);
        jaxrsOutFlowServerSideGlobalHandlers.removeReference(handlerRef);

        String importPackage = handlerRef.getBundle().getHeaders("").get("Import-package");
        String dynamicImportPackage = handlerRef.getBundle().getHeaders("").get("DynamicImport-Package");

        if ((importPackage != null && importPackage.contains("javax.xml.ws.handler.soap")) ||
            (dynamicImportPackage != null && dynamicImportPackage.contains("javax.xml.ws.handler.soap")))
        {
            saajCount.getAndDecrement();
        }

        clearAllList();

        //jaxws
        Iterator<Handler> registeredHandlers = jaxwsInFlowServerSideGlobalHandlers.getServices();
        while (registeredHandlers.hasNext()) {
            jaxwsInFlowServerSideGlobalHandlers1.add(registeredHandlers.next());
        }

        registeredHandlers = jaxwsOutFlowServerSideGlobalHandlers.getServices();
        while (registeredHandlers.hasNext()) {
            jaxwsOutFlowServerSideGlobalHandlers1.add(0, registeredHandlers.next());
        }

        registeredHandlers = jaxwsInFlowClientSideGlobalHandlers.getServices();
        while (registeredHandlers.hasNext()) {
            jaxwsInFlowClientSideGlobalHandlers1.add(registeredHandlers.next());
        }

        registeredHandlers = jaxwsOutFlowClientSideGlobalHandlers.getServices();
        while (registeredHandlers.hasNext()) {
            jaxwsOutFlowClientSideGlobalHandlers1.add(0, registeredHandlers.next());
        }
        //jaxrs
        registeredHandlers = jaxrsOutFlowServerSideGlobalHandlers.getServices();
        while (registeredHandlers.hasNext()) {
            jaxrsOutFlowServerSideGlobalHandlers1.add(0, registeredHandlers.next());
        }

        registeredHandlers = jaxrsInFlowServerSideGlobalHandlers.getServices();
        while (registeredHandlers.hasNext()) {
            jaxrsInFlowServerSideGlobalHandlers1.add(registeredHandlers.next());
        }

        registeredHandlers = jaxrsOutFlowClientSideGlobalHandlers.getServices();
        while (registeredHandlers.hasNext()) {
            jaxrsOutFlowClientSideGlobalHandlers1.add(0, registeredHandlers.next());
        }

        registeredHandlers = jaxrsInFlowClientSideGlobalHandlers.getServices();
        while (registeredHandlers.hasNext()) {
            jaxrsInFlowClientSideGlobalHandlers1.add(registeredHandlers.next());
        }

    }
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;
	}
584515
@Override
  public void handlerRemoved(final ChannelHandlerContext ctx) throws Exception {
    if (responseContent != null && responseContent.refCnt() > 0) {
      responseContent.release();
      responseContent = null;
    }
  }
1080870
private void purgeHandle(String handle) {
        write.lock();
        try {
            kamMap.remove(handle);

            Set<Entry<FilteredKAMKey, String>> entries = fltrdMap.entrySet();
            Iterator<Entry<FilteredKAMKey, String>> iter = entries.iterator();
            while (iter.hasNext()) {
                Entry<FilteredKAMKey, String> next = iter.next();
                if (handle.equals(next.getValue())) {
                    iter.remove();
                }
            }

            Set<Entry<KamInfo, String>> entries2 = unfltrdMap.entrySet();
            Iterator<Entry<KamInfo, String>> iter2 = entries2.iterator();
            while (iter2.hasNext()) {
                Entry<KamInfo, String> next = iter2.next();
                if (handle.equals(next.getValue())) {
                    iter2.remove();
                }
            }
        } finally {
            write.unlock();
        }
    }
227055
def CloseHandle(self):
        ''''''
        if hasattr(self, 'handle'):
            ret = vmGuestLib.VMGuestLib_CloseHandle(self.handle.value)
            if ret != VMGUESTLIB_ERROR_SUCCESS: raise VMGuestLibException(ret)
            del(self.handle)
839356
public void remove(Object e)
    {
        // Invoke Pre Remove Events

        // TODO Check for validity also as per JPA
        if (e == null)
        {
            throw new IllegalArgumentException("Entity to be removed must not be null.");
        }

        EntityMetadata metadata = getMetadata(e.getClass());

        // Create an object graph of the entity object
        ObjectGraph graph = new GraphGenerator().generateGraph(e, this, new ManagedState());

        Node node = graph.getHeadNode();

        try
        {
            lock.writeLock().lock();

            // TODO : push into action queue, get original end-point from
            // persistenceContext first!

            // Action/ExecutionQueue/ActivityQueue :-> id, name, EndPoint,
            // changed
            // state

            // Change state of node, after successful flush processing.
            node.setPersistenceDelegator(this);
            node.remove();

            // build flush stack.

            flushManager.buildFlushStack(node, EventType.DELETE);

            // Flush node.
            flush();
        }
        finally
        {
            lock.writeLock().unlock();
        }
        // clear out graph
        graph.clear();
        graph = null;

        if (log.isDebugEnabled())
        {
            log.debug("Data removed successfully for entity : " + e.getClass());
        }
    }
278112
public boolean unregisterBlockListener(String handle) throws InvalidArgumentException {

        if (shutdown) {
            throw new InvalidArgumentException(format("Channel %s has been shutdown.", name));
        }

        checkHandle(BLOCK_LISTENER_TAG, handle);
        logger.trace(format("Unregister BlockListener with handle %s.", handle));

        LinkedHashMap<String, BL> lblockListeners = blockListeners;
        if (lblockListeners == null) {
            return false;
        }

        synchronized (lblockListeners) {

            return null != lblockListeners.remove(handle);

        }
    }