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

@param _id id of the type to get
@return instance of class {@link Dimension}
@throws CacheReloadException on error
162507
public static Dimension get(final long _id)
        throws CacheReloadException
    {
        final Cache<Long, Dimension> cache = InfinispanCache.get().<Long, Dimension>getCache(Dimension.IDCACHE);
        if (!cache.containsKey(_id)) {
            Dimension.getDimensionFromDB(Dimension.SQL_ID, _id);
        }
        return cache.get(_id);
    }
837084
public static Group get(final long _id)
        throws CacheReloadException
    {
        final Cache<Long, Group> cache = InfinispanCache.get().<Long, Group>getCache(Group.IDCACHE);
        if (!cache.containsKey(_id) && !Group.getGroupFromDB(Group.SQL_ID, _id)) {
            cache.put(_id, Group.NULL, 100, TimeUnit.SECONDS);
        }
        final Group ret = cache.get(_id);
        return ret.equals(Group.NULL) ? null : ret;
    }
721414
public static Dimension get(final String _name)
        throws CacheReloadException
    {
        final Cache<String, Dimension> cache = InfinispanCache.get().<String, Dimension>getCache(Dimension.NAMECACHE);
        if (!cache.containsKey(_name)) {
            Dimension.getDimensionFromDB(Dimension.SQL_NAME, _name);
        }
        return cache.get(_name);
    }
981689
public com.ibm.websphere.cache.CacheEntry getEntry(String id) {
        return getEntry((Object) id);
    }
303960
protected T get(Connection conn, BoId id) {
        if (id == null || id.values == null || id.values.length == 0) {
            return null;
        }
        final String cacheKey = cacheKey(id);
        T bo = getFromCache(getCacheName(), cacheKey, typeClass);
        if (bo == null) {
            bo = executeSelectOne(rowMapper, conn, calcSqlSelectOne(id), id.values);
            putToCache(getCacheName(), cacheKey, bo);
        }
        return bo;
    }
562563
public static Menu get(final UUID _uuid)
        throws CacheReloadException
    {
        return AbstractUserInterfaceObject.<Menu>get(_uuid, Menu.class, CIAdminUserInterface.Menu.getType());
    }
234083
public static Type get(final long _id)
        throws CacheReloadException
    {
        final Cache<Long, Type> cache = InfinispanCache.get().<Long, Type>getCache(Type.IDCACHE);
        if (!cache.containsKey(_id)) {
            Type.getTypeFromDB(Type.SQL_ID, _id);
        }
        Type ret = cache.get(_id);
        if (ret != null && ret.isDirty()) {
            Type.LOG.debug("Recaching dirty Type for id: {}", ret);
            Type.cacheType(ret);
            ret = cache.get(_id);
        }
        return ret;
    }
690407
public static Dimension get(final UUID _uuid)
        throws CacheReloadException
    {
        final Cache<UUID, Dimension> cache = InfinispanCache.get().<UUID, Dimension>getCache(Dimension.UUIDCACHE);
        if (!cache.containsKey(_uuid)) {
            Dimension.getDimensionFromDB(Dimension.SQL_UUID, String.valueOf(_uuid));
        }
        return cache.get(_uuid);
    }
1180606
public Resource<?> getObject(final int id) {
        return ObjectCache.from(WaylandServerCore.INSTANCE()
                                                 .wl_client_get_object(this.pointer,
                                                                       id));
    }
521509
public static Image get(final long _id)
        throws CacheReloadException
    {
        return AbstractUserInterfaceObject.<Image>get(_id, Image.class, CIAdminUserInterface.Image.getType());
    }
807478
protected static function getCache($id)
    {
        $type = static::getType();

        $id = (string)$id;

        static::initializeCache($type);

        $collection = self::$cache->{$type};

        if (!property_exists($collection, $id)) {
            return null;
        }

        $resource = $collection->{$id};

        return (clone $resource);
    }
940114
public static Store get(final String _name)
        throws CacheReloadException
    {
        final Cache<String, Store> cache = InfinispanCache.get().<String, Store>getCache(Store.NAMECACHE);
        if (!cache.containsKey(_name)) {
            Store.getStoreFromDB(CIDB.Store.Name, _name);
        }
        return cache.get(_name);
    }
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}`
}
130898
public <T> T get(Long id, Class<T> type) throws StorageException {
        T rval;
        EntityManager entityManager = getActiveEntityManager();
        try {
            rval = entityManager.find(type, id);
        } catch (Throwable t) {
            logger.error(t.getMessage(), t);
            throw new StorageException(t);
        }
        return rval;
    }
575238
public static Image get(final UUID _uuid)
        throws CacheReloadException
    {
        return AbstractUserInterfaceObject.<Image>get(_uuid, Image.class, CIAdminUserInterface.Image.getType());
    }
563921
public function setCacheableIdentifier(string $id = null, int $length = null): self
    {
        if ($id) {
            if (!preg_match('/^[a-zA-Z0-9\_\-\~\.]{8,32}$/', $id)) {
                throw new CacheException('Invalid value passed to "setCacheableIdentifier" method');
            }

            $this->cacheableId = $id;
            $this->cacheableIdLength = strlen($id);
        }

        if ($length) {
            if ($length < 100 || $length <= $this->cacheableIdLength) {
                throw new CacheException('Length of encoded Cacheable objects must start from at least 100');
            }

            $this->cacheableLengthFrom = $length;
        }

        return $this;
    }
1130926
public CacheEntry readCacheEntry(Object id) { // SKS-O
        Result result = htod.readCacheEntry(id);
        if (result.returnCode == HTODDynacache.DISK_EXCEPTION) {
            stopOnError(result.diskException);
            this.htod.returnToResultPool(result);
            return null;
        }
        CacheEntry cacheEntry = (CacheEntry) result.data;
        this.htod.returnToResultPool(result);
        return cacheEntry;
    }