Remove this sub-session from this session.
@param sessionObject The session to remove.
@return true If successful.
343949
public boolean removeSessionObject(BaseSession sessionObject)
    {
        if (m_vSessionObjectList == null)
            return false;
        boolean bFlag = m_vSessionObjectList.removeElement(sessionObject);
        return bFlag;
    }
734165
public static void removeSshSession(GlobalSessionObject<Map<String, SSHConnection>> sessionParam, String sessionId) {
        if (sessionParam != null) {
            SessionResource<Map<String, SSHConnection>> resource = sessionParam.getResource();
            if (resource != null) {
                Map<String, SSHConnection> tempMap = resource.get();
                if (tempMap != null) {
                    tempMap.remove(sessionId);
                }
            }
        }
    }
850455
@Override
    public void removeEventListener(EventListener listener) {
        if (listener instanceof SessionListener) {
            sessionListeners.remove(listener);
        }
        if (listener instanceof SessionAttributeListener) {
            sessionAttributeListeners.remove(listener);
        }
    }
744038
public boolean remove(Object obj) {
        Entry tab[] = mTable;

        if (obj == null) {
            obj = NULL;
        }

        int hash = obj.hashCode();
        int index = (hash & 0x7FFFFFFF) % tab.length;

        for (Entry e = tab[index], prev = null; e != null; e = e.mNext) {
            Object entryValue = e.get();

            if (entryValue == null) {
                // Clean up after a cleared Reference.
                mModCount++;
                if (prev != null) {
                    prev.mNext = e.mNext;
                }
                else {
                    tab[index] = e.mNext;
                }
                mCount--;
            }
            else if (e.mHash == hash) {
                mModCount++;
                if (prev != null) {
                    prev.mNext = e.mNext;
                }
                else {
                    tab[index] = e.mNext;
                }
                mCount--;

                return true;
            }
            else {
                prev = e;
            }
        }

        return false;
    }
871829
def delete_session(self, client_id):
        
        try:
            session = self._sessions[client_id][0]
        except KeyError:
            session = None
        if session is None:
            self.logger.debug("Delete session : session %s doesn't exist" % client_id)
            return

        # Delete subscriptions
        self.logger.debug("deleting session %s subscriptions" % repr(session))
        self._del_all_subscriptions(session)

        self.logger.debug("deleting existing session %s" % repr(self._sessions[client_id]))
        del self._sessions[client_id]
730901
public void removeSession(Session session) {
		InetSocketAddress remoteSocketAddress = session
				.getRemoteSocketAddress();
		log.warn("Remove a session: "
				+ SystemUtils.getRawAddress(remoteSocketAddress) + ":"
				+ remoteSocketAddress.getPort());
		this.sessionList.remove(session);
	}
124616
public void putSessionObject(@Nonnull final String key, @Nullable final Object obj) {
    this.lock();
    try {
      if (obj == null) {
        this.sessionObjects.remove(key);
      } else {
        this.sessionObjects.put(key, obj);
      }
    } finally {
      this.unlock();
    }
  }
796011
public Object superRemove(Object id) {
        if (com.ibm.websphere.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_WAS.isLoggable(Level.FINE)) {
            LoggingUtil.SESSION_LOGGER_WAS.entering(methodClassName, methodNames[SUPER_REMOVE]);
        }

        Object o = super.remove(id);
        if (o != null) {
            removeFromRecentlyInvalidatedList((String) id);
        }
        return o;
    }
630578
public void sessionDestroyed(final HttpSessionEvent event) {
		final HttpSession session = event.getSession();
		final String id = session.getId();
		SESSIONS.remove(id);
		counter--;
	}
531538
@Override
    public void removedService(ServiceReference<SessionDestroyedListener> serviceReference,
            SessionDestroyedListener object) {
        if (LOGGER.isDebugEnabled()) {
            LOGGER.debug("Listener [" + serviceReference + "] has been removed.");
        }

        final SessionDestroyedListener listener = context.getService(serviceReference);
        handler.removeListener(listener);
    }
780137
private boolean removeServantRoutingAffinity() {
        if (ivServantRoutingAffinity) {
            StatefulSessionKey sskey = (StatefulSessionKey) beanId.getPrimaryKey();
            byte[] pKeyBytes = sskey.getBytes();

            int retcode = container.ivStatefulBeanEnqDeq.SSBeanDeq(pKeyBytes, !home.beanMetaData.sessionActivateTran, true);
            if (retcode != 0) {
                if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled())
                    Tr.event(tc, "Could not DEQ session bean with key = " + sskey);
                return false;
            }

            ivServantRoutingAffinity = false;
        }

        return true;
    }
484823
private boolean internalRemove(Object o, boolean publicApi) {

        if (!contains(o)) return false;

        // todo: for multithreaded usage this block needs to be synchronized
        BeanContextChild bcc = null;
        if (o instanceof BeanContextProxy) {
            bcc = ((BeanContextProxy) o).getBeanContextProxy();
        }
        else if (o instanceof BeanContextChild) {
            bcc = (BeanContextChild) o;
        }

        if (bcc != null) {

            /*
             If remove invoked as a result of the BeanContext receiving an unexpected PropertyChangeEvent
             notification as a result of a 3rd party invoking setBeanContext() then the remove implementation
             shall not invoke setBeanContext(null) on that child as part of the remove() semantics, since
             doing so would overwrite the value previously set by the 3rd party.
            */
            if (publicApi) {

                // remove the property/veto listeners -- we know we want to remove the bean
                // and don't need to be notified if we have initiated the removal
                bcc.removePropertyChangeListener("beanContext", _childPcl);
                bcc.removeVetoableChangeListener("beanContext", _childVcl);

                try {
                    bcc.setBeanContext(null);
                }
                catch (PropertyVetoException e) {
                    // rewire the listeners we removed above then except
                    bcc.addPropertyChangeListener("beanContext", _childPcl);
                    bcc.addVetoableChangeListener("beanContext", _childVcl);
                    throw new IllegalStateException(e);
                }
            }
        }

        if (o instanceof BeanContextMembershipListener) {
            removeBeanContextMembershipListener((BeanContextMembershipListener) o);
        }

        BCChild bc = _children.get(o);
        if (bc.isProxy()) {
            _children.remove(bc.getChild());
        }
        else if (bc.hasProxy()) {
            _children.remove(bc.getProxy());
        }
        _children.remove(o);

        BeanContextMembershipEvent bcme = new BeanContextMembershipEvent((BeanContext) getPeer(), new Object[]{o});
        fireMembershipEvent(bcme, false);
        // end synchronized block
        return true;
    }
453982
@Override
    public boolean remove(Object o) {
        Integer id = indexOf((Record) o);
        if(id == null) {
            return false;
        }
        remove(id);
        return true;
    }
573107
@Override
    public void dispose(final Session session) {
        if (session != null && session.isConnected()) {
            logger.trace("Disposing of hibernate session.");
            session.close();
        }
    }
341238
@Override
    public void unregisterObject(Object object) {
        if (object instanceof IContextEvent) {
            for (IManagedContext<?> managedContext : managedContexts) {
                managedContext.removeSubscriber((IContextEvent) object);
            }
        }

        if (object instanceof IManagedContext) {
            managedContexts.remove(object);
        }
    }
297084
@Override
	public int unregisterTopicSession(String topic, Session session) {
		if (isInconsistenceContext(topic, session)) {
			return 0;
		}
		logger.debug("'{}' unsubscribe to '{}'", session.getId(), topic);
		if (Constants.Topic.ALL.equals(topic)) {
			for (Map.Entry<String, Collection<Session>> entry : map.entrySet()) {
				Collection<Session> sessions = entry.getValue();
				removeSessionToSessions(session, sessions);
				if (sessions.isEmpty()) {
					map.remove(entry.getKey());
				}
			}
		} else {
			Collection<Session> sessions = map.get(topic);
			removeSessionToSessions(session, sessions);
			if (sessions==null || sessions.isEmpty()) {
				map.remove(topic);
			}
		}
		return getNumberSubscribers(topic);
	}
71027
@Override
    public Object remove(String name) {
        final HttpSession session = this.getPortalSesion(false);
        if (session == null) {
            return null;
        }

        final Object sessionMutex = WebUtils.getSessionMutex(session);
        synchronized (sessionMutex) {
            final Object attribute = session.getAttribute(name);
            if (attribute != null) {
                session.removeAttribute(name);
            }

            return attribute;
        }
    }