Removes the counter for the given {@code serviceName} and {@code dataStructureName}.
3613
public void removeCounter(String serviceName, String dataStructureName) {
        for (WanPublisherEventCounters publisherWanCounterContainer : eventCounterMap.values()) {
            publisherWanCounterContainer.removeCounter(serviceName, dataStructureName);
        }
    }
674555
@Override
	public void purge(long tillWhen){
		Long t;
		while((t = ((NavigableMap<Long, AtomicLong>)counters.getMap()).firstKey()) != null && t < tillWhen){
			counters.remove(t);
		}
	}
803566
public long count(String serviceName, String dataStructureName, String methodName) {
        return ((LatencyProbeImpl) newProbe(serviceName, dataStructureName, methodName)).stats.count;
    }
902394
protected synchronized void removeAdminObjectService(ServiceReference<AdminObjectService> reference) {
        String id = (String) reference.getProperty(ADMIN_OBJECT_CFG_ID);
        if (id != null) {
            removeAdminObjectService(reference, id, false);

            String jndiName = (String) reference.getProperty(ADMIN_OBJECT_CFG_JNDI_NAME);
            if (jndiName != null && !jndiName.equals(id)) {
                removeAdminObjectService(reference, jndiName, true);
            }
        }
    }
1176047
public OperationFuture<List<Server>> removeSecondaryNetworks(ServerFilter filter) {
        return removeSecondaryNetworks(Arrays.asList(getRefsFromFilter(filter)));
    }
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());
            }
        }
    }
1003648
public void unregisterInstance(String serviceName, String instanceId, boolean isOwned){
        String uri = toInstanceUri(serviceName, instanceId) + "/" + isOwned;
        HttpResponse result = invoker.invoke(uri, null,
                HttpMethod.DELETE);

        if (result.getHttpCode() != HTTP_OK) {
            throw new ServiceException(ErrorCode.REMOTE_DIRECTORY_SERVER_ERROR,
                    "HTTP Code is not OK, code=%s", result.getHttpCode());
        }
    }
186132
@Override
	public void removeByCommerceNotificationTemplateId(
		long commerceNotificationTemplateId) {
		for (CommerceNotificationQueueEntry commerceNotificationQueueEntry : findByCommerceNotificationTemplateId(
				commerceNotificationTemplateId, QueryUtil.ALL_POS,
				QueryUtil.ALL_POS, null)) {
			remove(commerceNotificationQueueEntry);
		}
	}
247518
public Result<T> remove(ServiceInfo.Key key)
    {
        T previous = null;

        lock();
        try
        {
            ServiceType serviceType = keysToServiceTypes.remove(key);
            if (serviceType == null) return new Result<T>(null, null);
            previous = keysToServiceInfos.remove(key);
            previous.setRegistered(false);
        }
        finally
        {
            unlock();
        }

        notifyServiceRemoved(previous, null);
        return new Result<T>(previous, null);
    }
136853
@Override
    public void removeEndPoint(String name) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(tc, "Deleting endpoint: " + name);
        }

        synchronized (this.endpoints) {
            if (this.endpoints.remove(name) != null) {
                unregisterMBeanInService(name);
            }
        }
    }
773682
public void removeNotificationHandler(String serviceName, NotificationHandler handler) {

        ServiceInstanceUtils.validateServiceName(serviceName);
        if (handler == null) {
            throw new ServiceException(ErrorCode.SERVICE_DIRECTORY_NULL_ARGUMENT_ERROR,
                    ErrorCode.SERVICE_DIRECTORY_NULL_ARGUMENT_ERROR.getMessageTemplate(),
                    "NotificationHandler");
        }
        List<InstanceChangeListener<ModelServiceInstance>> list = changeListenerMap.get(serviceName);
        if (list != null) {
            boolean found = false;
            for (InstanceChangeListener<ModelServiceInstance> listener : list) {
                if (listener instanceof NotificationHandlerAdapter
                        && ((NotificationHandlerAdapter) listener).getAdapter() == handler) {
                    list.remove(listener);
                    found = true;
                    break;
                }
            }
            if (!found) {
               LOGGER.error(ErrorCode.NOTIFICATION_HANDLER_DOES_NOT_EXIST.getMessageTemplate());
            }
        } else {
            LOGGER.error(String.format(ErrorCode.SERVICE_DOES_NOT_EXIST.getMessageTemplate(), serviceName));
        }

    }
619728
public void removeHostName(String hostName) {
		if(logger.isDebugEnabled()) {
			logger.debug("Removing hostname "+ hostName);
		}
		hostNames.remove(hostName);
		if(dnsServerLocator != null) {
			dnsServerLocator.removeLocalHostName(hostName);
		}
	}
991486
public void unregisterServiceInstance(String serviceName, String instanceId, final RegistrationCallback cb, Object context){
        ProtocolHeader header = new ProtocolHeader();
        header.setType(ProtocolType.UnregisterServiceInstance);

        UnregisterServiceInstanceProtocol p = new UnregisterServiceInstanceProtocol(serviceName, instanceId);
        ProtocolCallback pcb = new ProtocolCallback(){

            @Override
            public void call(boolean result, Response response,
                    ErrorCode error, Object ctx) {
                cb.call(result, error, ctx);
            }

        };
        connection.submitCallbackRequest(header, p, pcb, context);
    }
264570
protected void remove(CmsUUID structureId, String rootPath, int type) {

        if (!isContainerConfiguration(rootPath, type)) {
            return;
        }
        m_updateSet.add(structureId);
    }
1319181
public static <E> void removeKeys(Counter<E> counter, Collection<E> removeKeysCollection) {

    for (E key : removeKeysCollection)
      counter.remove(key);
  }
277634
public static void removeWeakCounter(Cache<WeakCounterKey, CounterValue> cache, CounterConfiguration configuration,
         String counterName) {
      ByteString counterNameByteString = ByteString.fromString(counterName);
      for (int i = 0; i < configuration.concurrencyLevel(); ++i) {
         cache.remove(new WeakCounterKey(counterNameByteString, i));
      }
   }
85540
public synchronized void removeUpdatesForQueue( String queueName )
    {
    	Iterator<TransactionItem> entries = items.iterator();
    	while (entries.hasNext())
		{
    		TransactionItem item = entries.next();
    		if (item.getDestination().getName().equals(queueName))
    		    entries.remove();
		}
    }