Creating model knowledge

src/main/java/org/gcube/informationsystem/knowledge/ModelKnowledge.java

@@ -1,13 +1,26 @@
 package org.gcube.informationsystem.knowledge;
 
+import java.util.AbstractMap.SimpleEntry;
 import java.util.Collection;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.Map;
+import java.util.Map.Entry;
 import java.util.Set;
 
 import org.gcube.informationsystem.base.reference.AccessType;
+import org.gcube.informationsystem.base.reference.entities.EntityElement;
+import org.gcube.informationsystem.model.reference.entities.Facet;
+import org.gcube.informationsystem.model.reference.entities.Resource;
+import org.gcube.informationsystem.model.reference.relations.ConsistsOf;
+import org.gcube.informationsystem.model.reference.relations.IsRelatedTo;
+import org.gcube.informationsystem.model.reference.relations.Relation;
 import org.gcube.informationsystem.tree.NodeInformation;
 import org.gcube.informationsystem.tree.Tree;
+import org.gcube.informationsystem.types.PropertyTypeName;
+import org.gcube.informationsystem.types.TypeMapper;
+import org.gcube.informationsystem.types.impl.properties.PropertyDefinitionImpl;
+import org.gcube.informationsystem.types.reference.Type;
 import org.gcube.informationsystem.types.reference.entities.FacetType;
 import org.gcube.informationsystem.types.reference.entities.ResourceType;
 import org.gcube.informationsystem.types.reference.properties.LinkedEntity;
@@ -28,7 +41,8 @@ public class ModelKnowledge<T, NI extends NodeInformation<T>> {
 	protected Map<AccessType, Tree<T>> trees;
 	protected Map<AccessType, UsageKnowledge<?>> usageKnowledges;
 
-	public ModelKnowledge() {
+	public ModelKnowledge(NI nodeInformation) {
+		this.nodeInformation = nodeInformation;
 		reset();
 	}
 	
@@ -52,7 +66,7 @@ public class ModelKnowledge<T, NI extends NodeInformation<T>> {
 				 * In this way we have a complete overview of the usege of the
 				 * property type
 				 */
-				usageKnowledge = new UsageKnowledge<Map<T,PropertyDefinition>>(accessType);
+				usageKnowledge = new UsageKnowledge<Map.Entry<T,PropertyDefinition>>(accessType);
 			}else {
 				usageKnowledge = new UsageKnowledge<LinkedEntity>(accessType);
 			}
@@ -61,7 +75,7 @@ public class ModelKnowledge<T, NI extends NodeInformation<T>> {
 				
 	}
 	
-	protected void add(LinkedEntity linkedEntity, UsageKnowledge<LinkedEntity> relationUsage, UsageKnowledge<LinkedEntity> targetEntityUsage) {
+	protected void addUsage(LinkedEntity linkedEntity, UsageKnowledge<LinkedEntity> relationUsage, UsageKnowledge<LinkedEntity> targetEntityUsage) {
 		if (linkedEntity != null) {
 			@SuppressWarnings("unchecked")
 			UsageKnowledge<LinkedEntity> resourceUsage = (UsageKnowledge<LinkedEntity>) usageKnowledges.get(AccessType.RESOURCE);
@@ -74,23 +88,63 @@ public class ModelKnowledge<T, NI extends NodeInformation<T>> {
 		}
 	}
 
-	protected void addAll(Collection<LinkedEntity> linkedEntities, UsageKnowledge<LinkedEntity> relationUsage, UsageKnowledge<LinkedEntity> targetEntityUsage) {
+	protected void addAllUsage(Collection<LinkedEntity> linkedEntities, UsageKnowledge<LinkedEntity> relationUsage, UsageKnowledge<LinkedEntity> targetEntityUsage) {
 		if(linkedEntities!=null) {
 			for(LinkedEntity le : linkedEntities) {
-				add(le, relationUsage, targetEntityUsage);
+				addUsage(le, relationUsage, targetEntityUsage);
 			}
 		}
 	}
 
-	protected void addPropertyUsage(Set<PropertyDefinition> properties, UsageKnowledge<PropertyDefinition> propertyUsage) {
-		// for()
+	protected void addPropertyUsage(T t, Set<PropertyDefinition> properties, UsageKnowledge<Map.Entry<T,PropertyDefinition>> propertyUsage) {
+		if(properties==null || properties.size()==0) {
+			return;
+		}
+		for(PropertyDefinition propertyDefinition : properties) {
+			PropertyTypeName propertyTypeName = ((PropertyDefinitionImpl) propertyDefinition).getPropertyTypeName();
+			if(propertyTypeName.isGenericType()) {
+				SimpleEntry<T,PropertyDefinition> entry = new SimpleEntry<>(t, propertyDefinition);
+				propertyUsage.add(propertyTypeName.getGenericClassName(), entry);
+			}
+		}
+	}
+	
+	protected void addMetadataUsage(T t, UsageKnowledge<Entry<T, PropertyDefinition>> propertyUsage) {
+		Type type = TypeMapper.createTypeDefinition(EntityElement.class);
+		addPropertyUsage(t, type.getProperties(), propertyUsage);
+	}
+	
+	protected void addPropagationConstraintUsage(T t, UsageKnowledge<Entry<T, PropertyDefinition>> propertyUsage) {
+		Type type = TypeMapper.createTypeDefinition(Relation.class);
+		addPropertyUsage(t, type.getProperties(), propertyUsage);
+	}
+
+	public void addAllType(Collection<T> types) {
+		Set<T> toRetry = new HashSet<>();
+		
+		for(T t : types) {
+			logger.trace("Going to add {}", nodeInformation.getIdentifier(t));
+			try {
+				addType(t);
+			}catch (RuntimeException e) {
+				toRetry.add(t);
+			}
+		}
+		
+		if(toRetry.size()>0) {
+			addAllType(toRetry);
+		}
 	}
 	
 	public void addType(T t) {
 		AccessType accessType = nodeInformation.getAccessType(t);
+		String typeName = nodeInformation.getIdentifier(t);
+		
+		Tree<T> tree = trees.get(accessType);
+		tree.addNode(t);
 		
 		@SuppressWarnings("unchecked")
-		UsageKnowledge<PropertyDefinition> propertyUsage = (UsageKnowledge<PropertyDefinition>) usageKnowledges.get(AccessType.PROPERTY);
+		UsageKnowledge<Map.Entry<T,PropertyDefinition>> propertyUsage = (UsageKnowledge<Map.Entry<T,PropertyDefinition>>) usageKnowledges.get(AccessType.PROPERTY);
 		
 		@SuppressWarnings("unchecked")
 		UsageKnowledge<LinkedEntity> resourceUsage = (UsageKnowledge<LinkedEntity>) usageKnowledges.get(AccessType.RESOURCE);
@@ -108,33 +162,49 @@ public class ModelKnowledge<T, NI extends NodeInformation<T>> {
 	
 			case RESOURCE:
 				ResourceType resourceType = (ResourceType) t;
-				addAll(resourceType.getFacets(), consistsOfUsage, facetUsage);
-				addAll(resourceType.getResources(), isRelatedToUsage, resourceUsage);
+				addAllUsage(resourceType.getFacets(), consistsOfUsage, facetUsage);
+				addAllUsage(resourceType.getResources(), isRelatedToUsage, resourceUsage);
+				
+				/* 
+				 * Metadata is defined in parent type i.e. EntityElement. 
+				 * We want to have a reference to all Base type
+				 */ 
+				if(typeName.compareTo(Resource.NAME)==0) {
+					addMetadataUsage(t, propertyUsage);
+				}
 				break;
 			
 			case FACET:
 				FacetType facetType = (FacetType) t;
-				addPropertyUsage(facetType.getProperties(), propertyUsage);
+				if(typeName.compareTo(Facet.NAME)==0) {
+					addMetadataUsage(t, propertyUsage);
+				}
+				addPropertyUsage(t, facetType.getProperties(), propertyUsage);
+				
 				break;
 			
 			case IS_RELATED_TO:
 				IsRelatedToType isRelatedToType = (IsRelatedToType) t;
-				
+				if(typeName.compareTo(IsRelatedTo.NAME)==0) {
+					addMetadataUsage(t, propertyUsage);
+					addPropagationConstraintUsage(t, propertyUsage);
+				}
+				addPropertyUsage(t, isRelatedToType.getProperties(), propertyUsage);
 				break;
 			
 			case CONSISTS_OF:
 				ConsistsOfType consistsOfType = (ConsistsOfType) t;
-				
+				if(typeName.compareTo(ConsistsOf.NAME)==0) {
+					addMetadataUsage(t, propertyUsage);
+					addPropagationConstraintUsage(t, propertyUsage);
+				}
+				addPropertyUsage(t, consistsOfType.getProperties(), propertyUsage);
 				break;
 			
 			default:
 				break;
 		}
 		
-		if(accessType == AccessType.RESOURCE) {
-			
-			
-		}
 	}
 	
 	public Tree<T> getTree(AccessType accessType) {

src/main/java/org/gcube/informationsystem/knowledge/UsageKnowledge.java

@@ -1,9 +1,9 @@
 package org.gcube.informationsystem.knowledge;
 
+import java.util.ArrayList;
 import java.util.LinkedHashMap;
+import java.util.List;
 import java.util.Map;
-import java.util.Set;
-import java.util.TreeSet;
 
 import org.gcube.informationsystem.base.reference.AccessType;
 
@@ -12,23 +12,23 @@ import org.gcube.informationsystem.base.reference.AccessType;
  */
 public class UsageKnowledge<U> {
 	
-	protected Map<String, Set<U>> map;
+	protected Map<String, List<U>> map;
 	
 	public UsageKnowledge(AccessType accessType){
 		this.map = new LinkedHashMap<>();
 	}
 	
 	public void add(String typeName, U u) {
-		Set<U> list = map.get(typeName);
+		List<U> list = map.get(typeName);
 		if(list==null) {
-			list = new TreeSet<>();
+			list = new ArrayList<>();
 			map.put(typeName, list);
 		}
 		list.add(u);
 	}
 	
-	public Set<U> getUsage(String typeName){
-		Set<U> list = map.get(typeName);
+	public List<U> getUsage(String typeName){
+		List<U> list = map.get(typeName);
 		return list;
 	}
 	

src/test/java/org/gcube/informationsystem/knowledge/ModelKnowledgeTest.java

@@ -0,0 +1,101 @@
+package org.gcube.informationsystem.knowledge;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.URL;
+import java.nio.charset.Charset;
+import java.nio.file.Files;
+import java.util.List;
+import java.util.Set;
+
+import org.gcube.com.fasterxml.jackson.databind.JsonNode;
+import org.gcube.com.fasterxml.jackson.databind.ObjectMapper;
+import org.gcube.informationsystem.base.reference.AccessType;
+import org.gcube.informationsystem.queries.templates.QueryTemplateTest;
+import org.gcube.informationsystem.tree.Node;
+import org.gcube.informationsystem.tree.NodeElaborator;
+import org.gcube.informationsystem.tree.Tree;
+import org.gcube.informationsystem.types.TypeMapper;
+import org.gcube.informationsystem.types.reference.Type;
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * @author Luca Frosini (ISTI - CNR)
+ */
+public class ModelKnowledgeTest{
+	
+	private static final Logger logger = LoggerFactory.getLogger(ModelKnowledgeTest.class);
+	
+	protected File getTypesDirectory() throws Exception {
+		URL logbackFileURL = QueryTemplateTest.class.getClassLoader().getResource("logback-test.xml");
+		File logbackFile = new File(logbackFileURL.toURI());
+		File resourcesDirectory = logbackFile.getParentFile();
+		return new File(resourcesDirectory, "types");
+	}
+	
+	protected String readFile(File file) throws IOException {
+		byte[] encoded = Files.readAllBytes(file.toPath());
+		return new String(encoded, Charset.defaultCharset());
+	}
+	
+	@Test
+	public void test() throws Exception {
+		ModelKnowledge<Type, TypeInformation> modelKnowledge = new ModelKnowledge<>(new TypeInformation());
+		
+		File typesDirectory = getTypesDirectory();
+		
+		AccessType[] modelTypes = AccessType.getModelTypes();
+		for(AccessType modelType : modelTypes) {
+			File file = new File(typesDirectory, modelType.getName() + ".json");
+			String json = readFile(file);
+			List<Type> types = TypeMapper.deserializeTypeDefinitions(json);
+			modelKnowledge.addAllType(types);
+		}
+		
+		for(AccessType modelType : modelTypes) {
+			Tree<Type> tree = modelKnowledge.getTree(modelType);
+			
+			tree.elaborate(new NodeElaborator<Type>() {
+				
+				@Override
+				public void elaborate(Node<Type> node, int level) throws Exception {
+					StringBuffer stringBuffer = new StringBuffer();
+					for (int i = 0; i < level; ++i) {
+						stringBuffer.append(Node.INDENTATION);
+					}
+					
+					String typeName = node.getNodeElement().getName();
+					logger.info("{}- {}{}", stringBuffer.toString(), typeName, level==0 ? " (ROOT)" : "");
+					
+				}
+			});			
+		}
+		
+		logger.info("---------------------------------------------------\n\n\n");
+		
+		for(AccessType modelType : modelTypes) {
+			Tree<Type> tree = modelKnowledge.getTree(modelType);
+			UsageKnowledge<?> usageKnowledge = modelKnowledge.getUsageKnowledge(modelType);
+			
+			tree.elaborate(new NodeElaborator<Type>() {
+				
+				@Override
+				public void elaborate(Node<Type> node, int level) throws Exception {
+					StringBuffer stringBuffer = new StringBuffer();
+					for (int i = 0; i < level; ++i) {
+						stringBuffer.append(Node.INDENTATION);
+					}
+					
+					String typeName = node.getNodeElement().getName();
+					List<?> usage = usageKnowledge.getUsage(typeName);
+					
+					logger.info("{}- {}{} {}", stringBuffer.toString(), typeName, level==0 ? " (ROOT) " : "", usage!=null ? "known usage from definitions "  + usage : "No known usage from definitions");
+					
+				}
+			});			
+		}
+		
+	}	
+}

src/test/java/org/gcube/informationsystem/types/SerializationTest.java

@@ -23,6 +23,7 @@ import org.gcube.informationsystem.queries.templates.reference.properties.Templa
 import org.gcube.informationsystem.serialization.ElementMapper;
 import org.gcube.informationsystem.types.annotations.Final;
 import org.gcube.informationsystem.types.reference.Change;
+import org.gcube.informationsystem.types.reference.Type;
 import org.gcube.informationsystem.types.reference.TypeMetadata;
 import org.gcube.informationsystem.types.reference.entities.EntityType;
 import org.gcube.informationsystem.types.reference.entities.FacetType;
@@ -63,6 +64,13 @@ public class SerializationTest {
 		EntityType resourceTypeDefinitionSelf = (EntityType) TypeMapper.createTypeDefinition(ResourceType.class);
 		logger.info(ElementMapper.marshal(resourceTypeDefinitionSelf));
 	}
+
+	@Test
+	public void entityElementDefinition() throws Exception{
+		Type type = TypeMapper.createTypeDefinition(EntityElement.class);
+		logger.info(ElementMapper.marshal(type));
+	}
+	
 	
 	@Test
 	public void testPropertyTypeDefinition() throws Exception{