Invalidate.

@param serviceId the service id
327574
@DeleteOperation
    public void invalidate(@Nullable final String serviceId) {
        if (StringUtils.isBlank(serviceId)) {
            cachingMetadataResolver.invalidate();
        } else {
            val registeredService = findRegisteredService(serviceId);
            val criteriaSet = new CriteriaSet();
            criteriaSet.add(new EntityIdCriterion(serviceId));
            criteriaSet.add(new EntityRoleCriterion(SPSSODescriptor.DEFAULT_ELEMENT_NAME));
            cachingMetadataResolver.invalidate(registeredService, criteriaSet);
        }
    }
438958
public void resetRetryCount(String clientId)
	{
		Integer currentRetryCount = this.retryCounts.get(clientId);
		if (currentRetryCount != null && currentRetryCount.intValue() != 0)
		{
			this.retryCounts.put(clientId, 0);
		}
	}
1138536
public void invalidate(@Nullable Uri uri) {
    if (uri != null) {
      cache.clearKeyUri(uri.toString());
    }
  }
1275267
public void invalidate(String name){
        lock(name);
        try{
            cache.remove(name);
            created.remove(name);
            gets.remove(name);
        }finally {
            unlock(name);
        }
    }
633672
def invalidate(self, callback=True):
        # type: (bool) -> bool
        
        with self._lock:
            if self.state != StoredInstance.VALID:
                # Instance is not running...
                return False

            # Change the state
            self.state = StoredInstance.INVALID

            # Call the handlers
            self.__safe_handlers_callback("pre_invalidate")

            # Call the component
            if callback:
                # pylint: disable=W0212
                self.__safe_validation_callback(
                    constants.IPOPO_CALLBACK_INVALIDATE
                )

                # Trigger an "Invalidated" event
                self._ipopo_service._fire_ipopo_event(
                    constants.IPopoEvent.INVALIDATED,
                    self.factory_name,
                    self.name,
                )

            # Call the handlers
            self.__safe_handlers_callback("post_invalidate")
            return True
547529
def delete(self, id, attid): # pylint: disable=invalid-name,redefined-builtin
        
        return self.service.edit(self._base(id), attid)
688804
public void unregisterService(String serviceName, String providerId) {
        getServiceDirectoryClient().unregisterInstance(serviceName, providerId, disableOwnerError);
    }
338812
public void remove(Identity oid)
    {
        if (oid == null) return;

        ObjectCache cache = getCache(oid, null, METHOD_REMOVE);
        if (cache != null)
        {
            cache.remove(oid);
        }
    }
574133
public final void invalidateAllKeys(String dataStructureName, String sourceUuid) {
        checkNotNull(sourceUuid, "sourceUuid cannot be null");

        int orderKey = getPartitionId(dataStructureName);
        Invalidation invalidation = newClearInvalidation(dataStructureName, sourceUuid);
        sendImmediately(invalidation, orderKey);
    }
261006
public void invalidate() {
        synchronized (mMeasuredChildren) {
            Log.d(Log.SUBSYSTEM.LAYOUT, TAG, "invalidate all [%d]", mMeasuredChildren.size());
            mMeasuredChildren.clear();
        }
    }
828708
public synchronized void remove(int requestId)
   {
		if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "remove");
		
      if (!containsId(requestId))
      {
         if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) debugTraceTable("id ("+requestId+") not in table");
         throw new SIErrorException(nls.getFormattedMessage("REQIDTABLE_INTERNAL_SICJ0058", null, "REQIDTABLE_INTERNAL_SICJ0058")); // D226223
      }

      testReqIdTableEntry.requestId = requestId;
      table.remove(testReqIdTableEntry);

		if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "remove");
   }
1350286
public void removeSessions(PrimitiveId primitiveId) {
    sessions.entrySet().removeIf(e -> e.getValue().getService().serviceId().equals(primitiveId));
  }
1158117
private void destroyService(ServiceHandle<S> serviceHandle) {
        try {
            _serviceFactory.destroy(serviceHandle.getEndPoint(), serviceHandle.getService());
        } catch (Exception e) {
            // this should not happen, but if it does, swallow the exception and log it
            LOG.warn("Error destroying serviceHandle", e);
        }
    }
62078
public void unload(String resourceId) {
        LoadableResource res = this.resources.get(resourceId);
        if (res!=null) {
            res.unload();
        }
    }
809530
public void invalidateAll() throws SecurityException {
        if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_CORE.isLoggable(Level.FINE)) {
            LoggingUtil.SESSION_LOGGER_CORE.logp(Level.FINE, methodClassName, "invalidateAll", "will default to invalidateAll(false)");
        }
        invalidateAll(false);
    }
785274
public void remove(Id id) {
        readCache.remove(new CacheKey(id));
        writeCache.remove(id);
    }
139763
public void serviceId_suspend_POST(Long serviceId) throws IOException {
		String qPath = "/service/{serviceId}/suspend";
		StringBuilder sb = path(qPath, serviceId);
		exec(qPath, "POST", sb.toString(), null);
	}