During the initial caching of types, the mapping does not exists but is necessary.
@param _typeUUID UUID of the type the id is wanted for
@return id of the type
@throws CacheReloadException on error
326179
protected static long getId4UUID(final UUID _typeUUID)
        throws CacheReloadException
    {
        long ret = 0;
        final Cache<UUID, Type> cache = InfinispanCache.get().<UUID, Type>getCache(Type.UUIDCACHE);
        if (cache.containsKey(_typeUUID)) {
            ret = cache.get(_typeUUID).getId();
        } else {
            Connection con = null;
            try {
                con = Context.getConnection();
                PreparedStatement stmt = null;
                try {
                    stmt = con.prepareStatement(Type.SQL_UUID);
                    stmt.setObject(1, _typeUUID.toString());
                    final ResultSet rs = stmt.executeQuery();
                    while (rs.next()) {
                        ret = rs.getLong(1);
                    }
                    rs.close();
                } finally {
                    if (stmt != null) {
                        stmt.close();
                    }
                }
                con.commit();
            } catch (final SQLException e) {
                throw new CacheReloadException("could not read child type ids", e);
            } catch (final EFapsException e) {
                throw new CacheReloadException("could not read child type ids", 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;
    }
824385
public static String getCachedSourceCode(final String uuid) throws FrameworkException {

		final SchemaMethod method = StructrApp.getInstance().get(SchemaMethod.class, uuid);
		if (method != null) {

			final String source = method.getProperty(SchemaMethod.source);
			if (source != null) {

				return "${" + source.trim() + "}";
			}
		}

		return "${}";
	}
1085232
public static Command get(final UUID _uuid)
        throws CacheReloadException
    {
        return AbstractUserInterfaceObject.<Command>get(_uuid, Command.class, CIAdminUserInterface.Command.getType());
    }
942064
private Map<String, ComponentDto> indexExistingDtosByUuids(DbSession session) {
    return dbClient.componentDao().selectAllComponentsFromProjectKey(session, treeRootHolder.getRoot().getDbKey())
      .stream()
      .collect(Collectors.toMap(ComponentDto::uuid, Function.identity()));
  }
488328
public static Table get(final String _name)
        throws CacheReloadException
    {
        return AbstractUserInterfaceObject.<Table>get(_name, Table.class, CIAdminUserInterface.Table.getType());
    }
789929
@UsedByGeneratedCode
	public static ReloadableType getReloadableType(int typeRegistryId, int typeId) {
		if (GlobalConfiguration.verboseMode && log.isLoggable(Level.INFO)) {
			log.info(
					">TypeRegistry.getReloadableType(typeRegistryId=" + typeRegistryId + ",typeId=" + typeId + ")");
		}
		TypeRegistry typeRegistry = registryInstances[typeRegistryId].get();
		if (typeRegistry == null) {
			throw new IllegalStateException("Request to access registry id " + typeRegistryId
					+ " but no registry with that id has been created");
		}
		ReloadableType reloadableType = typeRegistry.getReloadableType(typeId);
		if (reloadableType == null) {
			throw new IllegalStateException("The type registry " + typeRegistry + " does not know about type id "
					+ typeId);
		}
		reloadableType.setResolved();
		if (GlobalConfiguration.verboseMode && log.isLoggable(Level.INFO)) {
			log.info("<TypeRegistry.getReloadableType(typeRegistryId=" + typeRegistryId + ",typeId=" + typeId
					+ ") returning " + reloadableType);
		}
		reloadableType.createTypeAssociations();
		return reloadableType;
	}
1183611
public function getOneByUuid($uuid)
	{
		$identifierPayload = $this->aggregate[IdentifierServiceProvider::getProviderKey()]->first(
			['filter' => ['uuid' => $uuid]]
		);

		if($identifierPayload->getStatus() != 'found')
		{
			return $identifierPayload;
		}

		return $this->aggregate[$this->formatEntityType($identifierPayload->getData()->getEntityType())]->first(
			['filter' => ['id' => $identifierPayload->getData()->getEntityKey()]]
		);
	}
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);
    }
520644
public Set<Type> getTypes()
        throws CacheReloadException
    {
        final Set<Type> ret = new HashSet<>();
        for (final Long id : this.types) {
            ret.add(Type.get(id));
        }
        return Collections.unmodifiableSet(ret);
    }
521509
public static Image get(final long _id)
        throws CacheReloadException
    {
        return AbstractUserInterfaceObject.<Image>get(_id, Image.class, CIAdminUserInterface.Image.getType());
    }
145378
public org.efaps.admin.ui.Table getType()
    {
        org.efaps.admin.ui.Table ret = null;
        try {
            ret =  org.efaps.admin.ui.Table.get(this.uuid);
        } catch (final CacheReloadException e) {
            CITable.LOG.error("Error on retrieving Type for CIType with uuid: {}", this.uuid);
        }
        return ret;
    }
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);
    }
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);
    }
1281804
@Basic
    @Column(name = "UIDENT", unique = true, nullable = false, length=255)
    public String getUid()
    {
        return this.uid;
    }
699262
public UUID toUuid() {
        if (mValue.length != 16) {
            throw new UnsupportedOperationException("Only Identifiers backed by a byte array with length of exactly 16 can be UUIDs.");
        }
        LongBuffer buf = ByteBuffer.wrap(mValue).asLongBuffer();
        return new UUID(buf.get(), buf.get());
    }
98819
public static Search get(final String _name)
        throws CacheReloadException
    {
        return AbstractUserInterfaceObject.<Search>get(_name, Search.class, CIAdminUserInterface.Search.getType());
    }
1347474
public static CachedInstanceQuery get4Request(final UUID _typeUUID)
        throws EFapsException
    {
        return new CachedInstanceQuery(Context.getThreadContext().getRequestId(), _typeUUID).setLifespan(5)
                        .setLifespanUnit(TimeUnit.MINUTES);
    }