Returns for given identifier in <i>_id</i> the cached instance of class
AccessType.

@param _id id of the search access type
@return instance of class AccessType
@throws CacheReloadException on error
339043
public static AccessType getAccessType(final long _id)
        throws CacheReloadException
    {
        final Cache<Long, AccessType> cache = InfinispanCache.get().<Long, AccessType>getCache(AccessType.IDCACHE);
        if (!cache.containsKey(_id)) {
            AccessType.getAccessTypeFromDB(AccessType.SQL_ID, _id);
        }
        return cache.get(_id);
    }
1197032
private static boolean getAccessSetFromDB(final String _sql,
                                              final Object _criteria)
        throws CacheReloadException
    {
        boolean ret = false;
        Connection con = null;
        try {
            AccessSet accessSet = null;
            con = Context.getConnection();
            PreparedStatement stmt = null;
            try {
                stmt = con.prepareStatement(_sql);
                stmt.setObject(1, _criteria);
                final ResultSet rs = stmt.executeQuery();

                if (rs.next()) {
                    final long id = rs.getLong(1);
                    final String uuid = rs.getString(2);
                    final String name = rs.getString(3);
                    AccessSet.LOG.debug("read AccessSet '{}' (id = {}, uuid ={})", name, id, uuid);
                    accessSet = new AccessSet(id, uuid, name);
                }
                ret = true;
                rs.close();
            } finally {
                if (stmt != null) {
                    stmt.close();
                }
            }
            con.commit();
            if (accessSet != null) {
                accessSet.readLinks2AccessTypes();
                accessSet.readLinks2DMTypes();
                accessSet.readLinks2Status();
                accessSet.readLinks2Person();
                // needed due to cluster serialization that does not update automatically
                AccessSet.cacheAccessSet(accessSet);
            }
        } catch (final SQLException e) {
            throw new CacheReloadException("could not read roles", e);
        } catch (final EFapsException e) {
            throw new CacheReloadException("could not read roles", e);
        } finally {
            try {
                if (con != null && !con.isClosed()) {
                    con.close();
                }
            } catch (final SQLException e) {
                throw new CacheReloadException("could not read child type ids", e);
            }
        }
        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);
    }
1145201
protected <T extends HistoryEvent> T findInCache(Class<T> type, String id) {
    return Context.getCommandContext()
      .getDbEntityManager()
      .getCachedEntity(type, id);
  }
558280
public static SQLTable get(final UUID _uuid)
        throws CacheReloadException
    {
        final Cache<UUID, SQLTable> cache = InfinispanCache.get().<UUID, SQLTable>getCache(SQLTable.UUIDCACHE);
        if (!cache.containsKey(_uuid)) {
            SQLTable.getSQLTableFromDB(SQLTable.SQL_UUID, String.valueOf(_uuid));
        }
        return cache.get(_uuid);
    }
55453
public static AccessType getAccessType(final UUID _uuid)
        throws CacheReloadException
    {
        final Cache<UUID, AccessType> cache = InfinispanCache.get().<UUID, AccessType>getCache(AccessType.UUIDCACHE);
        if (!cache.containsKey(_uuid)) {
            AccessType.getAccessTypeFromDB(AccessType.SQL_UUID, String.valueOf(_uuid));
        }
        return cache.get(_uuid);
    }
263159
public Type getLink()
        throws CacheReloadException
    {
        if (this.link == null) {
            Attribute.LOG.error("Access on Attribute Link without parent defintion: {}", this);
        }
        return Type.get(this.link);
    }
251374
private Set<Classification> getClassification(final List<Long> _classIds)
        throws CacheReloadException
    {
        final Set<Classification> noadd = new HashSet<>();
        final Set<Classification> add = new HashSet<>();
        if (_classIds != null) {
            for (final Long id : _classIds) {
                Classification clazz = (Classification) Type.get(id);
                if (!noadd.contains(clazz)) {
                    add.add(clazz);
                    while (clazz.getParentClassification() != null) {
                        clazz = clazz.getParentClassification();
                        if (add.contains(clazz)) {
                            add.remove(clazz);
                        }
                        noadd.add(clazz);
                    }
                }
            }
        }
        return add;
    }
1296943
public AuthenticationMethodType getAuthenticationMethodTypeForIdentifier(int id) {
		for (AuthenticationMethodType t : getAuthenticationMethodTypes())
			if (t.getUniqueIdentifier() == id)
				return t;
		return null;
	}
521509
public static Image get(final long _id)
        throws CacheReloadException
    {
        return AbstractUserInterfaceObject.<Image>get(_id, Image.class, CIAdminUserInterface.Image.getType());
    }
198570
public static Class<? extends Tag> getClassFor(int id) {
        if(!idToTag.containsKey(id)) {
            return null;
        }

        return idToTag.get(id);
    }
981689
public com.ibm.websphere.cache.CacheEntry getEntry(String id) {
        return getEntry((Object) id);
    }
485221
public static Command get(final long _id)
        throws CacheReloadException
    {
        return AbstractUserInterfaceObject.<Command>get(_id, Command.class, CIAdminUserInterface.Command.getType());
    }
999422
public static Status get(final long _id)
        throws CacheReloadException
    {
        final Cache<Long, Status> cache = InfinispanCache.get().<Long, Status>getCache(Status.IDCACHE4STATUS);
        if (!cache.containsKey(_id)) {
            Status.getStatusFromDB(Status.SQL_ID4STATUS, _id);
        }
        return cache.get(_id);
    }
1276749
public Object lookup(Identity oid)
    {
        processQueue();
        hitCount++;
        Object result = null;

        CacheEntry entry = (CacheEntry) objectTable.get(buildKey(oid));
        if(entry != null)
        {
            result = entry.get();
            if(result == null || entry.getLifetime() < System.currentTimeMillis())
            {
                /*
                cached object was removed by gc or lifetime was exhausted
                remove CacheEntry from map
                */
                gcCount++;
                remove(oid);
                // make sure that we return null
                result = null;
            }
            else
            {
                /*
                TODO: Not sure if this makes sense, could help to avoid corrupted objects
                when changed in tx but not stored.
                */
                traceIdentity(oid);
                if(log.isDebugEnabled()) log.debug("Object match " + oid);
            }
        }
        else
        {
            failCount++;
        }
        return result;
    }
940112
public CachedDbEntity getCachedEntity(Class<?> type, String id) {
    Class<?> cacheKey = cacheKeyMapping.getEntityCacheKey(type);
    Map<String, CachedDbEntity> entitiesByType = cachedEntites.get(cacheKey);
    if(entitiesByType != null) {
      return entitiesByType.get(id);
    } else {
      return null;
    }
  }
364225
public static Table get(final long _id)
        throws CacheReloadException
    {
        return AbstractUserInterfaceObject.<Table>get(_id, Table.class, CIAdminUserInterface.Table.getType());
    }