Unregisters the given client from this CacheManager.

@param client The client to unregister.
11476
public void unregister(Client client) {
        if (this.closed.get()) {
            // We are done. Nothing to do here.
            return;
        }

        Preconditions.checkNotNull(client, "client");
        synchronized (this.clients) {
            this.clients.remove(client);
        }

        log.info("{} Unregistered {}.", TRACE_OBJECT_ID, client);
    }
1017854
void unregisterReceiver() {
        try {
            final Context context = contextRef.get();
            if (context != null) {
                context.unregisterReceiver(receiver);
            }
        } catch (IllegalArgumentException e) {
        }
    }
1028668
public function unregister()
    {

        // query whether the cache is ready or if we aren't in production mode
        if (!$this->cacheIsReady || $this->environment !== 'production') {
            // If yes, unload the appropriate autoloader method
            spl_autoload_unregister(array($this, self::OUR_LOADER));
            return;
        }

        // the cache has been ready, so unregister the simple class loader
        spl_autoload_unregister(array($this, self::OUR_LOADER_PROD_NO_OMIT));
    }
1237857
function remove(client) {
  if(!clients) {
    return;
  }

  var idx = clients.indexOf(client);
  if(idx > -1) {
    clients.splice(idx, 1);
  }
}
707745
private synchronized void freeClient(Client client) {
        int current = useCounts.get(client);
        if (current > 0) {
            timestamps.put(client, System.currentTimeMillis());  // Mark that it was used until now.
            useCounts.put(client, current - 1);
            if ((current == 1) && (idleLimit.get() == 0)) {
                closeClient(client);  // This was the last use, and we are supposed to immediately close idle clients.
            }
        } else {
            logger.error("Ignoring attempt to free a client that is not allocated: {}", client);
        }
    }
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);
    }
829149
public static void close() {
        if (storedClient == null) {
            return;
        }

        storedClient.closeConnection();
        storedClient = null;

        // Allow the client to be auto initialized on the next use.
        autoInitAttempted.set(false);
    }
321033
public static void unregister(String name) {
    try {
      ManagementFactory.getPlatformMBeanServer().unregisterMBean(new ObjectName(name));
    } catch (Exception e) {
      LoggerFactory.getLogger(Jmx.class).warn("Can not unregister MBean [{}]", name, e);
    }
  }
192708
protected synchronized void deactivate(ComponentContext context) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(tc, "Unregistering JNDIEntry " + serviceRegistration);
        }
        if (this.serviceRegistration != null) {
            this.serviceRegistration.unregister();
        }
    }
699226
public static void unregisterMbean(MBeanServer server, ObjectName name) {
        try {
            server.unregisterMBean(name);
        } catch(Exception e) {
            logger.error("Error unregistering mbean", e);
        }
    }
1043280
@RequestMapping(value = "/api/profile/{profileIdentifier}/clients/delete", method = RequestMethod.POST)
    public
    @ResponseBody
    HashMap<String, Object> deleteClient(Model model,
                                         @RequestParam("profileIdentifier") String profileIdentifier,
                                         @RequestParam("clientUUID") String[] clientUUID) throws Exception {

        logger.info("Attempting to remove clients from the profile: ", profileIdentifier);
        logger.info("Attempting to remove the following clients: {}", Arrays.toString(clientUUID));

        HashMap<String, Object> valueHash = new HashMap<String, Object>();
        Integer profileId = ControllerUtils.convertProfileIdentifier(profileIdentifier);

        for( int i = 0; i < clientUUID.length; i++ )
        {
            if (clientUUID[i].compareTo(Constants.PROFILE_CLIENT_DEFAULT_ID) == 0)
                throw new Exception("Default client cannot be deleted");

            clientService.remove(profileId, clientUUID[i]);
        }

        valueHash.put("clients", clientService.findAllClients(profileId));
        return valueHash;
    }
505309
public static void unregisterListener(Context context, PlaybackListener listener) {
        LocalBroadcastManager.getInstance(context.getApplicationContext())
                .unregisterReceiver(listener);
    }
1334972
private void unregisterCachedServiceInstance(
            String serviceName, String providerId) {
        try {
            write.lock();
            ServiceInstanceId id = new ServiceInstanceId(serviceName, providerId);
            getCacheServiceInstances().remove(id);
            LOGGER.debug(
                    "delete cached ProvidedServiceInstance, serviceName={}, providerId={}.",
                    serviceName, providerId);
        } finally {
            write.unlock();
        }
    }
1313319
protected void unregister(IConnection conn, boolean deleteIfNoConns) {
        log.debug("Unregister connection ({}:{}) client id: {}", conn.getRemoteAddress(), conn.getRemotePort(), id);
        // remove connection from connected scopes list
        connections.remove(conn);
        // If client is not connected to any scope any longer then remove
        if (deleteIfNoConns && connections.isEmpty()) {
            // TODO DW dangerous the way this is called from BaseConnection.initialize(). Could we unexpectedly pop a Client out of the registry?
            removeInstance();
        }
    }
980368
public static void unregisterMXBean(CacheProxy<?, ?> cache, MBeanType type) {
    ObjectName objectName = getObjectName(cache, type);
    unregister(objectName);
  }
888788
synchronized void unregister() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(tc, "unregister", this);
        }
        if (registration != null) {
            registration.unregister();
            registration = null;
        }
    }
1017513
public void register(Client client) {
        Exceptions.checkNotClosed(this.closed.get(), this);
        Preconditions.checkNotNull(client, "client");
        synchronized (this.clients) {
            if (!this.clients.contains(client)) {
                this.clients.add(client);
                client.updateGenerations(this.currentGeneration.get(), this.oldestGeneration.get());
            }
        }

        log.info("{} Registered {}.", TRACE_OBJECT_ID, client);
    }