273 lines
7.8 KiB
Java
273 lines
7.8 KiB
Java
package org.gcube.informationsystem.types.impl;
|
|
|
|
import java.lang.reflect.Method;
|
|
import java.lang.reflect.ParameterizedType;
|
|
import java.lang.reflect.TypeVariable;
|
|
import java.util.HashMap;
|
|
import java.util.HashSet;
|
|
import java.util.Map;
|
|
import java.util.Set;
|
|
|
|
import org.gcube.com.fasterxml.jackson.annotation.JsonGetter;
|
|
import org.gcube.com.fasterxml.jackson.annotation.JsonIgnore;
|
|
import org.gcube.com.fasterxml.jackson.annotation.JsonInclude;
|
|
import org.gcube.com.fasterxml.jackson.annotation.JsonInclude.Include;
|
|
import org.gcube.com.fasterxml.jackson.annotation.JsonProperty;
|
|
import org.gcube.com.fasterxml.jackson.annotation.JsonSetter;
|
|
import org.gcube.informationsystem.base.reference.AccessType;
|
|
import org.gcube.informationsystem.base.reference.Element;
|
|
import org.gcube.informationsystem.base.reference.entities.EntityElement;
|
|
import org.gcube.informationsystem.base.reference.properties.PropertyElement;
|
|
import org.gcube.informationsystem.base.reference.relations.RelationElement;
|
|
import org.gcube.informationsystem.model.reference.properties.Header;
|
|
import org.gcube.informationsystem.types.TypeMapper;
|
|
import org.gcube.informationsystem.types.annotations.Abstract;
|
|
import org.gcube.informationsystem.types.annotations.ISProperty;
|
|
import org.gcube.informationsystem.types.impl.entities.EntityTypeImpl;
|
|
import org.gcube.informationsystem.types.impl.properties.PropertyDefinitionImpl;
|
|
import org.gcube.informationsystem.types.impl.properties.PropertyTypeImpl;
|
|
import org.gcube.informationsystem.types.impl.relations.RelationTypeImpl;
|
|
import org.gcube.informationsystem.types.reference.Type;
|
|
import org.gcube.informationsystem.types.reference.properties.PropertyDefinition;
|
|
import org.gcube.informationsystem.utils.TypeVersion;
|
|
import org.slf4j.Logger;
|
|
import org.slf4j.LoggerFactory;
|
|
|
|
/**
|
|
* @author Luca Frosini (ISTI - CNR)
|
|
*/
|
|
public class TypeImpl implements Type {
|
|
|
|
private static Logger logger = LoggerFactory.getLogger(TypeImpl.class);
|
|
|
|
/**
|
|
* Generated Serial version UID
|
|
*/
|
|
private static final long serialVersionUID = -4333954207969059451L;
|
|
|
|
/*
|
|
public final static String DESCRIPTION = "DESCRIPTION";
|
|
public final static String VERSION = "VERSION";
|
|
public final static String CHANGELOG = "CHANGELOG";
|
|
*/
|
|
|
|
public static final Map<TypeVersion, String> DEFAULT_CHANGELOG_MAP;
|
|
private static final Map<String, String> DEFAULT_CHANGELOG_MAP_KEY_AS_STRING;
|
|
|
|
static {
|
|
DEFAULT_CHANGELOG_MAP = new HashMap<>();
|
|
DEFAULT_CHANGELOG_MAP.put(new TypeVersion(TypeVersion.MINIMAL_VERSION_STRING), TypeVersion.MINIMAL_VERSION_DESCRIPTION);
|
|
DEFAULT_CHANGELOG_MAP_KEY_AS_STRING = new HashMap<>();
|
|
DEFAULT_CHANGELOG_MAP_KEY_AS_STRING.put(TypeVersion.MINIMAL_VERSION_STRING, TypeVersion.MINIMAL_VERSION_DESCRIPTION);
|
|
}
|
|
|
|
|
|
protected Header header;
|
|
|
|
protected String name;
|
|
protected String description;
|
|
protected TypeVersion version;
|
|
@JsonProperty(value = CHANGELOG_PROPERTY, required = false)
|
|
@JsonInclude(Include.NON_NULL)
|
|
protected Map<TypeVersion, String> changelog;
|
|
|
|
@JsonProperty(value = "abstract")
|
|
protected boolean abstractType;
|
|
protected Set<String> superClasses;
|
|
|
|
protected Set<PropertyDefinition> properties;
|
|
|
|
protected <E extends Element> Set<String> retrieveSuperClasses(Class<? extends E> type, Class<E> baseClass,
|
|
String topSuperClass) {
|
|
Set<String> interfaceList = new HashSet<>();
|
|
|
|
if (type == baseClass) {
|
|
if (topSuperClass != null) {
|
|
interfaceList.add(topSuperClass);
|
|
}
|
|
return interfaceList;
|
|
}
|
|
|
|
Class<?>[] interfaces = type.getInterfaces();
|
|
|
|
for (Class<?> interfaceClass : interfaces) {
|
|
|
|
if (!baseClass.isAssignableFrom(interfaceClass)) {
|
|
continue;
|
|
}
|
|
|
|
@SuppressWarnings("unchecked")
|
|
Class<? extends Element> clz = (Class<? extends Element>) interfaceClass;
|
|
interfaceList.add(TypeMapper.getType(clz));
|
|
}
|
|
|
|
return interfaceList;
|
|
}
|
|
|
|
protected Set<PropertyDefinition> retrieveListOfProperties(Class<?> type) {
|
|
Set<PropertyDefinition> properties = new HashSet<>();
|
|
for (Method m : type.getDeclaredMethods()) {
|
|
m.setAccessible(true);
|
|
if (m.isAnnotationPresent(ISProperty.class)) {
|
|
if (m.isBridge()) {
|
|
continue;
|
|
}
|
|
ISProperty propAnnotation = m.getAnnotation(ISProperty.class);
|
|
PropertyDefinition prop = new PropertyDefinitionImpl(propAnnotation, m);
|
|
properties.add(prop);
|
|
logger.trace("Property {} retrieved in type {} ", prop, type.getSimpleName());
|
|
}
|
|
|
|
}
|
|
if(properties.size()==0) {
|
|
properties = null;
|
|
}
|
|
return properties;
|
|
}
|
|
|
|
protected Class<?> getGenericClass(java.lang.reflect.Type type) {
|
|
TypeVariable<?> typeVariable = (TypeVariable<?>) type;
|
|
java.lang.reflect.Type[] bounds = typeVariable.getBounds();
|
|
java.lang.reflect.Type t = bounds[0];
|
|
if (t instanceof ParameterizedType) {
|
|
ParameterizedType parameterizedType = (ParameterizedType) t;
|
|
return (Class<?>) parameterizedType.getRawType();
|
|
}
|
|
return (Class<?>) t;
|
|
}
|
|
|
|
@SuppressWarnings({ "rawtypes", "unchecked" })
|
|
public static Type getInstance(Class<? extends Element> clz) {
|
|
Type typeDefinition = null;
|
|
try {
|
|
if (EntityElement.class.isAssignableFrom(clz)) {
|
|
typeDefinition = EntityTypeImpl.getEntityTypeDefinitionInstance((Class<? extends EntityElement>) clz);
|
|
return typeDefinition;
|
|
} else if (RelationElement.class.isAssignableFrom(clz)) {
|
|
typeDefinition = RelationTypeImpl
|
|
.getRelationTypeDefinitionInstance((Class<? extends RelationElement<?, ?>>) clz);
|
|
return typeDefinition;
|
|
} else if (PropertyElement.class.isAssignableFrom(clz)) {
|
|
typeDefinition = new PropertyTypeImpl(clz);
|
|
return typeDefinition;
|
|
} else if (Type.class.isAssignableFrom(clz)) {
|
|
typeDefinition = new TypeImpl(clz);
|
|
return typeDefinition;
|
|
} else {
|
|
throw new RuntimeException("Serialization required");
|
|
}
|
|
} finally {
|
|
if (typeDefinition != null) {
|
|
logger.debug("{} : {} ", clz, typeDefinition);
|
|
}
|
|
}
|
|
}
|
|
|
|
protected TypeImpl() {
|
|
}
|
|
|
|
|
|
|
|
protected TypeImpl(Class<? extends Element> clz) {
|
|
this.name = TypeMapper.getType(clz);
|
|
this.description = TypeMapper.getTypeDescription(clz);
|
|
this.version = TypeMapper.getTypeVersion(clz);
|
|
|
|
this.changelog = TypeMapper.getTypeChangelog(clz);
|
|
|
|
this.abstractType = false;
|
|
|
|
if (clz.isAnnotationPresent(Abstract.class)) {
|
|
this.abstractType = true;
|
|
}
|
|
|
|
}
|
|
|
|
@Override
|
|
public Header getHeader() {
|
|
return header;
|
|
}
|
|
|
|
@Override
|
|
public void setHeader(Header header) {
|
|
this.header = header;
|
|
}
|
|
|
|
@Override
|
|
public String getName() {
|
|
return name;
|
|
}
|
|
|
|
@Override
|
|
public String getDescription() {
|
|
return description;
|
|
}
|
|
|
|
@Override
|
|
public TypeVersion getVersion() {
|
|
return version;
|
|
}
|
|
|
|
@JsonGetter(value = VERSION_PROPERTY)
|
|
public String getVersionAsString() {
|
|
return version.toString();
|
|
}
|
|
|
|
@JsonSetter(value = VERSION_PROPERTY)
|
|
public void setVersion(String version) {
|
|
this.version = new TypeVersion(version);
|
|
}
|
|
|
|
@Override
|
|
public Map<TypeVersion, String> getChangelog() {
|
|
return changelog;
|
|
}
|
|
|
|
@JsonGetter(value = CHANGELOG_PROPERTY)
|
|
@JsonInclude(Include.NON_NULL)
|
|
public Map<String, String> getChangelogWithVersionAsString() {
|
|
if(this.changelog==null) {
|
|
return DEFAULT_CHANGELOG_MAP_KEY_AS_STRING;
|
|
}
|
|
Map<String, String> map = new HashMap<>();
|
|
for (TypeVersion typeVersion : changelog.keySet()) {
|
|
map.put(typeVersion.toString(), changelog.get(typeVersion));
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@JsonSetter(value=CHANGELOG_PROPERTY)
|
|
public void setChangelog(Map<String, String> changelog) {
|
|
if(changelog==null) {
|
|
this.changelog = DEFAULT_CHANGELOG_MAP;
|
|
return;
|
|
}
|
|
this.changelog = new HashMap<>();
|
|
for (String version : changelog.keySet()) {
|
|
this.changelog.put(new TypeVersion(version), changelog.get(version));
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean isAbstract() {
|
|
return abstractType;
|
|
}
|
|
|
|
@Override
|
|
public Set<String> getSuperClasses() {
|
|
return superClasses;
|
|
}
|
|
|
|
@JsonInclude(Include.NON_EMPTY)
|
|
public Set<PropertyDefinition> getProperties() {
|
|
return properties;
|
|
}
|
|
|
|
@Override
|
|
@JsonIgnore
|
|
public AccessType getAccessType() {
|
|
return null;
|
|
}
|
|
|
|
}
|