/**
* Adds the given alias to the cache in a {@literal null}-safe manner.
*
* @param key must not be {@literal null}.
* @param alias can be {@literal null}.
*/
private void safelyAddToCache(ClassTypeInformation<?> key, Object alias) {
CacheValue<Object> aliasToBeCached = CacheValue.ofNullable(alias);
if (alias == null && !typeMap.containsKey(key)) {
typeMap.put(key, aliasToBeCached);
return;
}
CacheValue<Object> alreadyCachedAlias = typeMap.get(key);
// Reject second alias for same type
if (alreadyCachedAlias != null
&& alreadyCachedAlias.isPresent()
&& !alreadyCachedAlias.hasValue(alias)) {
throw new IllegalArgumentException(
String.format(
"Trying to register alias '%s', but found already registered alias '%s' for type %s!",
alias, alreadyCachedAlias, key));
}
// Reject second type for same alias
if (typeMap.containsValue(aliasToBeCached)) {
for (Entry<ClassTypeInformation<?>, CacheValue<Object>> entry : typeMap.entrySet()) {
CacheValue<Object> value = entry.getValue();
if (!value.isPresent()) {
continue;
}
if (value.hasValue(alias) && !entry.getKey().equals(key)) {
throw new IllegalArgumentException(
String.format(
"Detected existing type mapping of %s to alias '%s' but attempted to bind the same alias to %s!",
key, alias, entry.getKey()));
}
}
}
typeMap.put(key, aliasToBeCached);
}
/*
* (non-Javadoc)
* @see org.springframework.data.convert.TypeInformationMapper#resolveTypeFrom(java.lang.Object)
*/
public ClassTypeInformation<?> resolveTypeFrom(Object alias) {
if (alias == null) {
return null;
}
for (Entry<ClassTypeInformation<?>, CacheValue<Object>> entry : typeMap.entrySet()) {
CacheValue<Object> cachedAlias = entry.getValue();
if (cachedAlias.hasValue(alias)) {
return entry.getKey();
}
}
for (PersistentEntity<?, ?> entity : mappingContext.getPersistentEntities()) {
if (alias.equals(entity.getTypeAlias())) {
return entity.getTypeInformation().getRawTypeInformation();
}
}
return null;
}