Returns for given parameter <i>_id</i> the instance of class
{@link Command}.

@param _id id to search in the cache
@return instance of class {@link Command}
@throws CacheReloadException on error
485221
public static Command get(final long _id)
        throws CacheReloadException
    {
        return AbstractUserInterfaceObject.<Command>get(_id, Command.class, CIAdminUserInterface.Command.getType());
    }
501000
static public Thread getThread(final long id) {
        final Thread[] threads = getAllThreads();
        for (Thread thread : threads)
            if (thread.getId() == id)
                return thread;
        return null;
    }
1326359
public static SystemConfiguration get(final long _id)
        throws CacheReloadException
    {
        final Cache<Long, SystemConfiguration> cache = InfinispanCache.get().<Long, SystemConfiguration>getCache(
                        SystemConfiguration.IDCACHE);
        if (!cache.containsKey(_id)) {
            SystemConfiguration.getSystemConfigurationFromDB(SystemConfiguration.SQL_ID, _id);
        }
        return cache.get(_id);
    }
15382
function cacheKey (id) {
    //  get cache id
    var cacheId = stableId({
        columnsId: this.cache.model.columnsId,
        modelViewInstanceIds: this.modelViewInstanceIds,
        recordIds: this.ids,
    })
    // create cache key
    return `${this.cache.model.name}:view:id:collection:${cacheId}`
}
850614
public ActionCommand getActionCommand(String commandId) {
        
        if (logger.isDebugEnabled()) {
            logger.debug("Attempting to retrieve ActionCommand with id ["
                         + commandId
                         + "] from the command registry.");
        }
        
        Object command = getCommand(commandId, ActionCommand.class);
        
        return (ActionCommand) command;
        
    }
146214
public static Store get(final UUID _uuid)
        throws CacheReloadException
    {
        final Cache<UUID, Store> cache = InfinispanCache.get().<UUID, Store>getCache(Store.UUIDCACHE);
        if (!cache.containsKey(_uuid)) {
            Store.getStoreFromDB(CIDB.Store.UUID, String.valueOf(_uuid));
        }
        return cache.get(_uuid);
    }
788900
public static String getRefId(String id) throws ServletException {
		return PageIndex.getRefId(
			getServletContext(),
			getRequest(),
			id
		);
	}
514995
@GetMapping(path = "/instances/{id}", produces = MediaType.APPLICATION_JSON_VALUE)
    public Mono<ResponseEntity<Instance>> instance(@PathVariable String id) {
        LOGGER.debug("Deliver registered instance with ID '{}'", id);
        return registry.getInstance(InstanceId.of(id))
                       .filter(Instance::isRegistered)
                       .map(ResponseEntity::ok)
                       .defaultIfEmpty(ResponseEntity.notFound().build());
    }
127697
public OvhSecret retrieve_POST(String id) throws IOException {
		String qPath = "/secret/retrieve";
		StringBuilder sb = path(qPath);
		HashMap<String, Object>o = new HashMap<String, Object>();
		addBody(o, "id", id);
		String resp = execN(qPath, "POST", sb.toString(), o);
		return convertTo(resp, OvhSecret.class);
	}
1259740
public static AttributeType get(final long _id)
        throws CacheReloadException
    {
        final Cache<Long, AttributeType> cache = InfinispanCache.get().<Long, AttributeType>getCache(
                        AttributeType.IDCACHE);
        if (!cache.containsKey(_id)) {
            AttributeType.getAttributeTypeFromDB(AttributeType.SQL_ID, _id);
        }
        return cache.get(_id);
    }
1245908
protected static function cache_get_by_id($id) {
        if (isset(self::$cache_contextsbyid[$id])) {
            return self::$cache_contextsbyid[$id];
        }
        return false;
    }
632770
public function get($cache_id, $return_data_only = false) {
		$result = $this->object->get($cache_id);
		// if we are debugging
		if (\Debug::$debug) {
			\Debug::$data['cache'][] = array(
				'type' => 'get',
				'link' => $this->object->cache_link,
				'cache_id' => $cache_id,
				'have_data' => $result['success']
			);
			// todo: log errors
		}
		// if we need to return data
		if ($return_data_only) {
			if ($result['success']) {
				return $result['data'];
			} else {
				return false;
			}
		} else {
			return $result;
		}
	}
572350
public OvhModuleList moduleList_id_GET(Long id) throws IOException {
		String qPath = "/hosting/web/moduleList/{id}";
		StringBuilder sb = path(qPath, id);
		String resp = execN(qPath, "GET", sb.toString(), null);
		return convertTo(resp, OvhModuleList.class);
	}
1291687
@Override
  public Entity findOneById(Object id) {
    if (cacheable
        && !transactionInformation.isEntireRepositoryDirty(getEntityType())
        && !transactionInformation.isEntityDirty(EntityKey.create(getEntityType(), id))) {
      return l2Cache.get(delegate(), id);
    }
    return delegate().findOneById(id);
  }
755337
public Result readCacheEntry(Object id, boolean calledFromRemove) {
        final String methodName = "readCacheEntry()";
        Result result = getFromResultPool();
        CacheEntry answer = null;
        if (this.invalidationBuffer.contains(id)) {
            return result;
        }
        HashtableEntry htEntry = null;
        boolean checkExpired = true;
        if (cache.isEnableListener() && cache.getEventSource().getInvalidationListenerCount() > 0 && this.cod.ignoreValueInInvalidationEvent == false) {
            checkExpired = false;
        }
        Object obj = null;
        try {
            rwLock.readLock().lock();
            //if (this.testException) {
            //    throw new FileManagerException("*** Generate filemanager exception");
            //}
            htEntry = object_cache.getHashTableEntry(id, checkExpired); // retrieve from HTOD
        } catch (FileManagerException ex) {
            this.diskCacheException = ex;
            result.diskException = ex;
            result.returnCode = DISK_EXCEPTION;
        } catch (HashtableOnDiskException ex) {
            this.diskCacheException = ex;
            result.diskException = ex;
            result.returnCode = DISK_EXCEPTION;
        } catch (IOException ex) {
            this.diskCacheException = ex;
            result.diskException = ex;
            result.returnCode = DISK_EXCEPTION;
        } catch (Exception ex) {
            result.returnCode = OTHER_EXCEPTION;
            result.diskException = ex;
        } finally {
            rwLock.readLock().unlock();
            if (result.returnCode != NO_EXCEPTION) {
                if (tc.isDebugEnabled())
                    Tr.debug(tc, methodName, "cacheName=" + this.cacheName + "\n Exception: " + ExceptionUtility.getStackTrace(result.diskException));
            }
            if (result.returnCode == DISK_EXCEPTION || result.returnCode == OTHER_EXCEPTION) {
                com.ibm.ws.ffdc.FFDCFilter.processException(result.diskException, "com.ibm.ws.cache.HTODDynacache.readCacheEntry", "916", this);
                return result;
            }
        }

        boolean expired = false;
        boolean alias = false;
        int dataSize = 0;
        Object origId = id;
        if (htEntry != null) {
            if (htEntry.isAliasId()) {
                alias = true;
                obj = htEntry.getValue();
                origId = obj;
                if (tc.isDebugEnabled())
                    Tr.debug(tc, methodName, "cacheName=" + this.cacheName + " found alias=" + id + " cacheId=" + origId);
                returnToHashtableEntryPool(htEntry);
                try {
                    rwLock.readLock().lock();
                    if (this.invalidationBuffer.contains(origId)) {
                        return result;
                    }
                    htEntry = object_cache.getHashTableEntry(origId, checkExpired); // retrieve from HTOD
                } catch (FileManagerException ex) {
                    this.diskCacheException = ex;
                    result.diskException = ex;
                    result.returnCode = DISK_EXCEPTION;
                } catch (HashtableOnDiskException ex) {
                    this.diskCacheException = ex;
                    result.diskException = ex;
                    result.returnCode = DISK_EXCEPTION;
                } catch (IOException ex) {
                    this.diskCacheException = ex;
                    result.diskException = ex;
                    result.returnCode = DISK_EXCEPTION;
                } catch (Exception ex) {
                    result.returnCode = OTHER_EXCEPTION;
                    result.diskException = ex;
                } finally {
                    rwLock.readLock().unlock();
                    if (result.returnCode != NO_EXCEPTION) {
                        if (tc.isDebugEnabled())
                            Tr.debug(tc, methodName, "cacheName=" + this.cacheName + "\n Exception: " + ExceptionUtility.getStackTrace(result.diskException));
                    }
                    if (result.returnCode == DISK_EXCEPTION || result.returnCode == OTHER_EXCEPTION) {
                        com.ibm.ws.ffdc.FFDCFilter.processException(result.diskException, "com.ibm.ws.cache.HTODDynacache.readCacheEntry", "916", this);
                        return result;
                    }
                }
            }
            if (htEntry != null) {
                if (htEntry.isExpired()) {
                    expired = true;
                    if (checkExpired) {
                        if (cache.isEnableListener() && cache.getEventSource().getInvalidationListenerCount() > 0) {
                            // In here - ignoreValueInInvalidationEvent = true
                            InvalidationEvent ie = new InvalidationEvent(origId, null, InvalidationEvent.DISK_TIMEOUT, InvalidationEvent.LOCAL, this.cache.getCacheName());
                            if (!this.invalidationBuffer.contains(origId)) {
                                this.cache.getEventSource().fireEvent(ie);
                            }
                        }
                        this.invalidationBuffer.add(origId, HTODInvalidationBuffer.EXPLICIT_BUFFER, CachePerf.TIMEOUT, CachePerf.LOCAL, !Cache.FROM_DEPID_TEMPLATE_INVALIDATION,
                                                    !HTODInvalidationBuffer.FIRE_EVENT, !HTODInvalidationBuffer.ALIAS_ID);
                        if (alias) {
                            this.invalidationBuffer.add(id, HTODInvalidationBuffer.EXPLICIT_BUFFER, CachePerf.TIMEOUT, CachePerf.LOCAL, !Cache.FROM_DEPID_TEMPLATE_INVALIDATION,
                                                        !HTODInvalidationBuffer.FIRE_EVENT, HTODInvalidationBuffer.ALIAS_ID);
                        }
                        if (this.cod.diskCachePerformanceLevel != CacheConfig.HIGH && !calledFromRemove) {
                            this.cache.internalInvalidateByDepId(origId, CachePerf.TIMEOUT, CachePerf.LOCAL, Cache.FIRE_INVALIDATION_LISTENER);
                        }
                        returnToHashtableEntryPool(htEntry);
                        return result;
                    }
                }
                // Retrieve CE and put data back in CE
                obj = htEntry.getValue();
                dataSize = htEntry.size();
                if (obj != null) {
                    try {
                        answer = (CacheEntry) SerializationUtility.deserialize((byte[]) obj, cacheName);
                        answer.setValidatorExpirationTime(htEntry.validatorExpirationTime());
                        byte[] serializedCacheValue = htEntry.getSerializedCacheValue();
                        if (serializedCacheValue != null) {
                            answer.serializedValue = serializedCacheValue;
                        }
                    } catch (Exception ex) {
                        result.returnCode = SERIALIZATION_EXCEPTION;
                        result.diskException = ex;
                        com.ibm.ws.ffdc.FFDCFilter.processException(result.diskException, "com.ibm.ws.cache.HTODDynacache.readCacheEntry", "953", this);
                        if (tc.isDebugEnabled())
                            Tr.debug(tc, methodName, "cacheName=" + this.cacheName + "\n Exception: " + ExceptionUtility.getStackTrace(result.diskException));
                    } finally {
                        returnToHashtableEntryPool(htEntry);
                    }
                }
            }
        }
        if (answer != null) {
            if (expired) {
                if (this.cache.isEnableListener() && cache.getEventSource().getInvalidationListenerCount() > 0) {
                    // In here - ignoreValueInInvalidationEvent = false
                    InvalidationEvent ie = new InvalidationEvent(answer.id, answer.serializedValue, InvalidationEvent.DISK_TIMEOUT, InvalidationEvent.LOCAL, this.cache.getCacheName());
                    if (!this.invalidationBuffer.contains(answer.id)) {
                        this.cache.getEventSource().fireEvent(ie);
                    }
                }
                this.invalidationBuffer.add(answer.id, HTODInvalidationBuffer.EXPLICIT_BUFFER, CachePerf.TIMEOUT, CachePerf.LOCAL, !Cache.FROM_DEPID_TEMPLATE_INVALIDATION,
                                            !HTODInvalidationBuffer.FIRE_EVENT, !HTODInvalidationBuffer.ALIAS_ID);
                for (int i = 0; i < answer.aliasList.length; i++) {
                    this.invalidationBuffer.add(answer.aliasList[i], HTODInvalidationBuffer.EXPLICIT_BUFFER, CachePerf.TIMEOUT, CachePerf.LOCAL,
                                                !Cache.FROM_DEPID_TEMPLATE_INVALIDATION, !HTODInvalidationBuffer.FIRE_EVENT, HTODInvalidationBuffer.ALIAS_ID);;
                }
                if (this.cod.diskCachePerformanceLevel != CacheConfig.HIGH && !calledFromRemove) {
                    //if (tc.isDebugEnabled()) Tr.debug(tc, methodName, "cacheName=" + this.cacheName + " id=" + answer.id + " check id as dep id");
                    this.cache.internalInvalidateByDepId(answer.id, CachePerf.TIMEOUT, CachePerf.LOCAL, Cache.FIRE_INVALIDATION_LISTENER);
                }
                answer = null;
            } else {
                if (!calledFromRemove && answer.serializedValue != null) {
                    this.cache.getCacheStatisticsListener().readEntryFromDisk(answer.id, dataSize);
                }
            }
        }
        result.data = answer;
        if (tc.isDebugEnabled())
            Tr.debug(tc, methodName, "cacheName=" + this.cacheName + " id=" + id + " cacheSizeInBytes=" + this.cod.currentCacheSizeInBytes);
        return result;
    }
1352424
public Integer getPreviousIDSeq(final String id) {
        Validate.notNull(id, "ID cannot be null");
        final Integer count = this.idCounts.get(id);
        if (count == null) {
            throw new TemplateProcessingException(
                    "Cannot obtain previous ID count for ID \"" + id + "\"");
        }
        return Integer.valueOf(count.intValue() - 1);
    }
908391
public static Attribute get(final long _id)
        throws CacheReloadException
    {
        final Cache<Long, Attribute> cache = InfinispanCache.get().<Long, Attribute>getCache(Attribute.IDCACHE);
        if (!cache.containsKey(_id)) {
            Type.get(Attribute.getTypeID(_id));
        }
        return cache.get(_id);
    }