Remove a J2CIdentityService reference. This method is called by
ThreadIdentityManagerConfigurator when a J2CIdentityService leaves
the OSGI framework.

@param j2cIdentityService
961510
public static void removeJ2CIdentityService(J2CIdentityService j2cIdentityService) {
        if (j2cIdentityService != null) {
            j2cIdentityServices.remove(j2cIdentityService);
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                Tr.debug(tc, "A J2CIdentityService implementation was removed.", j2cIdentityService.getClass().getName());
            }
        }
    }
939472
@Override
  public void deleteHistoricIdentityLink(String id) {
    if (isHistoryLevelAtLeast(HistoryLevel.AUDIT)) {
      getHistoricIdentityLinkEntityManager().delete(id);
    }
  }
1243997
protected void unsetSecurityService(SecurityService securityService) {
        SibTr.entry(tc, CLASS_NAME + "unsetSecurityService", securityService);

        SibTr.exit(tc, CLASS_NAME + "unsetSecurityService");
    }
231603
protected void destroyApplicationSession(final HttpServletRequest request, final HttpServletResponse response) {
        LOGGER.trace("Destroying application session");
        val context = new J2EContext(request, response, new J2ESessionStore());
        val manager = new ProfileManager<>(context, context.getSessionStore());
        manager.logout();

        val session = request.getSession(false);
        if (session != null) {
            val requestedUrl = session.getAttribute(Pac4jConstants.REQUESTED_URL);
            session.invalidate();
            if (requestedUrl != null && !requestedUrl.equals(StringUtils.EMPTY)) {
                request.getSession(true).setAttribute(Pac4jConstants.REQUESTED_URL, requestedUrl);
            }
        }
    }
797565
@Override
    public void removeInstanceChangeListener(String serviceName, ServiceInstanceChangeListener listener) throws ServiceException {
        ServiceInstanceUtils.validateManagerIsStarted(isStarted.get());
        ServiceInstanceUtils.validateServiceName(serviceName);
        if (listener == null) {
            throw new ServiceException(ErrorCode.SERVICE_DIRECTORY_NULL_ARGUMENT_ERROR,
                    ErrorCode.SERVICE_DIRECTORY_NULL_ARGUMENT_ERROR.getMessageTemplate(),
                    "ServiceInstanceChangeListener");
        }

        getLookupService().removeServiceInstanceChangeListener(serviceName, listener);
    }
1153692
public void setMessagingAuthenticationService(
			MessagingAuthenticationService messagingAuthenticationService) {
		if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
			SibTr.entry(tc, CLASS_NAME + "setMessagingAuthenticationService",
					messagingAuthenticationService);
		}
		this.messagingAuthenticationService = messagingAuthenticationService;
		if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
			SibTr.exit(tc, CLASS_NAME + "setMessagingAuthenticationService");
		}
	}
803829
protected void removeAdminObjectService(ServiceReference<AdminObjectService> reference, String id, boolean jndiName) {
        NamedAdminObjectServiceInfo aosInfo = adminObjectServices.get(id);
        if (aosInfo != null) {
            aosInfo.getServices(jndiName).removeReference(reference);

            // If the highest reference before updating is the one we just
            // removed, then we need to deactivate any endpoints using it.
            if (reference.equals(aosInfo.serviceRef)) {
                deactivateEndpoints(aosInfo.endpointFactories);

                // If there are no more references with this name, then clean
                // up the info object.  Otherwise, reactivate the endpoints
                // using the new admin object.
                if (aosInfo.updateServiceRef() == null) {
                    cleanupAdminObjectServiceInfo(aosInfo);
                } else {
                    activateDeferredEndpoints(aosInfo.endpointFactories);
                }
            } else {
                if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                    Tr.debug(tc, "unset reference not the primary reference");
                }
            }
        }

        // With the removal of an adminObjectService, there is a possibility
        // that some lookups could now fail, and endpoints which rely on them
        // need to deactivate until it becomes available again.
        updateSchemeJndiNames(false);

    }
1087777
void removeConsumer(JmsMsgConsumerImpl consumer) throws JMSException {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "removeConsumer", consumer);

        // if DUPS_OK_ACKNOWLEDGE is in use, commit any messages delivered in the
        // last incomplete batch (if the session is closing it will already have
        // done this and the count of uncommitted messages will be zero)
        if ((acknowledgeMode == Session.DUPS_OK_ACKNOWLEDGE) && (uncommittedReceiveCount > 0)) {
            commitTransaction();
        }
        syncConsumers.remove(consumer);
        asyncConsumers.remove(consumer);

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(this, tc, "removeConsumer");
    }
9287
public void removeSessionProvider(Object key)
   {
      if (providers.containsKey(key))
      {
         getSessionProvider(key).close();
         providers.remove(key);
      }

      if (systemProviders.containsKey(key))
      {
         systemProviders.get(key).close();
         systemProviders.remove(key);
      }
   }
298606
protected synchronized void deactivate(ComponentContext cc) {
        removeJMXSecurityFilter();

        pipelineRef.deactivate(cc);
        securityServiceRef.deactivate(cc);
    }
94152
@Override
  public void unregister(final Identifier id) throws IOException {
    final Link<NamingMessage> link = transport.open(serverSocketAddr, codec,
        new LoggingLinkListener<NamingMessage>());
    link.write(new NamingUnregisterRequest(id));
  }
504590
public void remove(Object pKey)
    {
        Identity id;
        if(pKey instanceof Identity)
        {
            id = (Identity) pKey;
        }
        else
        {
            id = transaction.getBroker().serviceIdentity().buildIdentity(pKey);
        }
        mhtObjectEnvelopes.remove(id);
        mvOrderOfIds.remove(id);
    }
263748
@Override
    public void removedService(ServiceReference<ManagedServiceFactory> reference, ManagedServiceFactory service) {
        String[] factoryPids = getServicePid(reference);

        if (factoryPids == null) {
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                Tr.debug(tc, "removedService(): Invalid service.pid type: " + reference);
            }
            return;
        }

        synchronized (caFactory.getConfigurationStore()) {
            for (String pid : factoryPids) {
                remove(reference, pid);
            }
        }

        context.ungetService(reference);
    }
877206
public static void removeThreadIdentityService(ThreadIdentityService tis) {
        if (tis != null) {
            threadIdentityServices.remove(tis);
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                Tr.debug(tc, "A ThreadIdentityService implementation was removed.", tis.getClass().getName());
            }
        }
    }
338812
public void remove(Identity oid)
    {
        if (oid == null) return;

        ObjectCache cache = getCache(oid, null, METHOD_REMOVE);
        if (cache != null)
        {
            cache.remove(oid);
        }
    }
935428
void removeConsumerSession(ConsumerSessionImpl consumer)
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "removeConsumerSession", consumer);

        synchronized (_consumers)
        {
            _consumers.remove(consumer);
        }

        _messageProcessor.removeConsumer(consumer);

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "removeConsumerSession");
    }
780685
public void remove(final boolean removeFromSession) {
        if (removeFromSession) {
            this.sessionStore.set(this.context, Pac4jConstants.USER_PROFILES, new LinkedHashMap<String, U>());
        }
        this.context.setRequestAttribute(Pac4jConstants.USER_PROFILES, new LinkedHashMap<String, U>());
    }