X-Git-Url: https://gerrit.simantics.org/r/gitweb?a=blobdiff_plain;f=org.simantics.xml.sax%2Fsrc%2Forg%2Fsimantics%2Fxml%2Fsax%2FOntologyGenerator.java;fp=org.simantics.xml.sax%2Fsrc%2Forg%2Fsimantics%2Fxml%2Fsax%2FOntologyGenerator.java;h=530798ed2844bab05acb6784e4085dd69d04544b;hb=ada38ab0a1a98dcb413bef3273064da36ce2d273;hp=0000000000000000000000000000000000000000;hpb=db6def39515fd442543064502a9ae7ae07ffc160;p=simantics%2Finterop.git

diff --git a/org.simantics.xml.sax/src/org/simantics/xml/sax/OntologyGenerator.java b/org.simantics.xml.sax/src/org/simantics/xml/sax/OntologyGenerator.java
new file mode 100644
index 0000000..530798e
--- /dev/null
+++ b/org.simantics.xml.sax/src/org/simantics/xml/sax/OntologyGenerator.java
@@ -0,0 +1,594 @@
+package org.simantics.xml.sax;
+
+import java.io.FileNotFoundException;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.util.ArrayList;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
+
+import javax.xml.namespace.QName;
+
+import org.simantics.utils.datastructures.BijectionMap;
+import org.simantics.xml.sax.configuration.AttributeComposition;
+import org.simantics.xml.sax.configuration.Configuration;
+import org.simantics.xml.sax.configuration.IDReference;
+import org.w3._2001.xmlschema.Annotated;
+import org.w3._2001.xmlschema.Attribute;
+import org.w3._2001.xmlschema.AttributeGroup;
+import org.w3._2001.xmlschema.Element;
+import org.w3._2001.xmlschema.LocalComplexType;
+import org.w3._2001.xmlschema.LocalSimpleType;
+import org.w3._2001.xmlschema.NamedAttributeGroup;
+import org.w3._2001.xmlschema.OpenAttrs;
+import org.w3._2001.xmlschema.Restriction;
+import org.w3._2001.xmlschema.Schema;
+import org.w3._2001.xmlschema.SimpleType;
+import org.w3._2001.xmlschema.TopLevelAttribute;
+
+public class OntologyGenerator extends SchemaConversionBase {
+	
+	public OntologyGenerator(Configuration configuration) {
+		super(configuration);
+	}
+
+	String ontRoot = "ONT.";
+	String commentTag = "//";
+	
+	Schema schema;
+	
+	String className;
+	
+	SchemaConverter converter;
+	
+	PrintWriter writer = null;
+	
+	public String getClassName() {
+		return className;
+	}
+	
+	public void createOntology(Schema schema, SchemaConverter converter) throws FileNotFoundException {
+		this.schema = schema;
+		this.converter = converter;
+		
+//		for (OpenAttrs attrs : schema.getIncludeOrImportOrRedefine()) {
+//			if (attrs instanceof Annotation) {
+//				Annotation ann = (Annotation)attrs;
+//				for (Object o : ann.getAppinfoOrDocumentation()) {
+//					if (o instanceof Documentation) {
+//						Documentation doc = (Documentation)o;
+//					} else if (o instanceof Appinfo) {
+//						Appinfo info = (Appinfo)o;
+//					}
+//				}
+//			}
+//		}
+		
+		
+		StringWriter stringWriter = null;
+		if (converter.getOntologyFile() == null) {
+			stringWriter = new StringWriter();
+			writer = new PrintWriter(stringWriter);
+		} else {
+			writer = new PrintWriter(converter.getOntologyFile());
+		}
+	
+		handle(schema);
+		
+		writer.flush();
+		writer.close();
+		if (stringWriter != null)
+			System.out.println(stringWriter.toString());
+	}
+	
+	protected void handle(Schema schema) {
+		String ontologyName = schema.getTargetNamespace();
+		if (ontologyName == null) {
+			ontologyName = converter.getSchemaFile().getName();
+			
+			int index = ontologyName.lastIndexOf(".");
+			if (index > 0)
+				ontologyName = ontologyName.substring(0, index);
+		} 
+		if (!ontologyName.startsWith("http"))
+			ontologyName = "http://" + ontologyName;
+		String parts[] = ontologyName.split("/");
+		String name = parts[parts.length-1];
+		ontRoot = name.substring(0, Math.min(3, name.length())).toUpperCase();
+		String version = schema.getVersion();
+		if (version == null)
+			version = "1.0";
+		
+		name = name.replaceAll("\\.", "_");
+		className = converter.getPluginName() + "." + name;
+		
+		for (String s : converter.getHeader()) {
+			writer.println(commentTag + " " + s);	
+		}
+		writer.println();
+		writer.println("L0 = <http://www.simantics.org/Layer0-1.1>");
+		writer.println();
+		writer.println(ontRoot + " = <" + ontologyName +"-"+ version+"> : L0.Ontology");
+		writer.println("   @L0.new");
+		writer.println("   L0.HasResourceClass \"" + className +"\"");
+		writer.println();
+		writer.println();
+		
+		ontRoot += ".";
+		// TODO : these could be created in separate base ontology.
+		writer.println(commentTag + " Built-in types");
+		writer.println();
+		writer.println(ontRoot+"XML : L0.Library");
+		writer.println(ontRoot+"XML.hasAttribute <R L0.HasProperty");
+		writer.println(ontRoot+"XML.hasID <R "+ontRoot+"XML.hasAttribute : L0.FunctionalRelation");
+		writer.println("  --> L0.String");
+		writer.println(ontRoot+"XML.ComplexType <T L0.Entity");
+		writer.println(ontRoot+"XML.hasComplexType <R L0.IsComposedOf");
+		writer.println(ontRoot+"XML.AttributeGroup  <T L0.Entity");
+		writer.println(ontRoot+"XML.Element <T L0.Entity");
+		writer.println(ontRoot+"XML.hasElement <R L0.IsComposedOf");
+		writer.println(ontRoot+"XML.ElementList <T L0.List");
+		writer.println(ontRoot+"XML.hasElementList <R L0.IsComposedOf");
+		writer.println(ontRoot+"XML.hasOriginalElementList <R " + ontRoot+"XML.hasElementList");
+		writer.println(ontRoot+"XML.hasReference <R L0.IsRelatedTo");
+		writer.println(ontRoot+"XML.hasExternalReference <R L0.IsRelatedTo");
+		writer.println("   L0.InverseOf " + ontRoot+"XML.externalReferenceOf <R L0.IsRelatedTo");
+		writer.println();
+		writer.println(ontRoot+"ComplexTypes : L0.Library");
+		writer.println(ontRoot+"AttributeGroups : L0.Library");
+		writer.println();
+		writer.println(commentTag + " Interpreted from schema");
+		writer.println();
+			
+		super.handle(schema);
+	}
+		
+	protected String getType(QName qtype) {
+		String ontType = getL0TypeFromPrimitiveType(qtype);
+		if (ontType != null)
+			return ontType;
+		else if (isComplexTypeRef(qtype.getLocalPart()))
+			return ontRoot+getComplexTypePrefix()+qtype.getLocalPart();
+		else if (isElementRef(qtype.getLocalPart()))
+			return ontRoot+qtype.getLocalPart();
+		else if (qtype.getPrefix() != null && qtype.getPrefix().length() > 0) {
+			return ontRoot+qtype.getPrefix()+qtype.getLocalPart();
+		}
+		throw new RuntimeException("Reference to unknown type " + qtype.getLocalPart());
+	}
+	
+	@Override
+	protected void handle(TopLevelAttribute topLevelAttribute) {
+		super.handle(topLevelAttribute);
+		writer.println();
+	}
+	
+	@Override
+	protected void handleSimpleType(SchemaObject topLevelSimpleType) {
+		super.handleSimpleType(topLevelSimpleType);
+		writer.println();
+	}
+	
+	
+	public static String getComplexTypePrefix() {
+		return "ComplexTypes.";
+	}
+	
+	public static String getAttributeGroupPrefix() {
+		return "AttributeGroups.";
+	}
+	
+	@Override
+	protected void handle(SchemaObject parent, SchemaElement indicator, List<SchemaElement> elements) {
+		if (indicator.getType() == SchemaElement.ElementType.SEQUENCE || (indicator.getType() == SchemaElement.ElementType.CHOICE && indicator.getRestriction().many())) {
+			for (SchemaElement e : elements) {
+				handle(parent, indicator, e);
+			}
+		} else if (indicator.getType() == SchemaElement.ElementType.CHOICE) {
+			String name = getChoiceName(elements);
+			boolean single = true;
+			for (SchemaElement e : elements) {
+				if (e.getRestriction().many()) {
+					single = false;
+					break;
+				}
+			}
+			String relationName = ontRoot+getName(parent)+".has"+name;
+			writer.print(relationName);
+			
+			List<String> types = new ArrayList<String>();
+			for (SchemaElement e : elements) {
+				Element localElement = e.getElement();
+				QName refType = null;
+				String type = null;
+				
+				if (localElement.getName() != null) {
+					refType = localElement.getType();
+					type = getL0TypeFromPrimitiveType(refType);	
+				} else if (localElement.getRef() != null) {
+					refType = localElement.getRef();
+					type = getL0TypeFromPrimitiveType(refType);
+				}
+				if (type == null) {
+					SchemaObject obj = getWithName(parent, refType.getLocalPart());
+					types.add(ontRoot+getName(obj,"has"));
+				} 
+			}
+			if (types.size() > 0) {
+				for (String type : types) {
+					writer.print(" <R " + type);
+				}
+			} else {
+				writer.print(" <R " +  ontRoot+"XML.hasElement");
+			}
+			
+			writer.println();
+			
+			for (SchemaElement e : elements) {
+				Element localElement = e.getElement();
+				QName refType = null;
+				String type = null;
+				if (localElement.getName() != null) {
+					refType = localElement.getType();
+					type = getType(refType);	
+				} else if (localElement.getRef() != null) {
+					refType = localElement.getRef();
+					type = getType(refType);
+				}
+				if (type != null) {
+					writer.println("   --> " + type);
+				}
+			}
+			if (!single) {
+				writer.println(ontRoot+name+ "List <T "+ontRoot+"XML.ElementList");
+				if (types.size() == 0) {
+				writer.println(relationName+ "List <R "+ontRoot+"XML.hasElementList : L0.FunctionalRelation");
+				} else {
+					writer.print(relationName+ "List");
+					for (String type : types) {
+						writer.print(" <R " + type+"List");
+					}
+					writer.println(" : L0.FunctionalRelation");
+				}
+				writer.println("   --> " + ontRoot+name+"List");
+			}
+		}
+		
+	}
+	
+	
+	
+	@Override
+	protected void handleIndicator(SchemaObject parent, SchemaElement indicator, SchemaElement element, boolean reference, String refName, QName refType) {
+		String type = getL0TypeFromPrimitiveType(refType);
+		SchemaObject obj = null;
+		if (type == null) {
+			obj = getWithName(parent, refType.getLocalPart());
+			
+			writer.println(ontRoot+getName(parent)+".has"+refName + " <R " +  ontRoot+ getName(obj,"has"));
+			writer.println("   --> " + ontRoot+getName(obj));
+		} else {
+			writer.println(ontRoot+getName(parent)+".has"+refName + " <R " +  ontRoot+"XML.hasElement");
+			writer.println("   --> " + getType(refType));
+		}
+		
+		if (useElementList(parent, indicator,element, reference, refName, refType)) {
+			
+			if (type == null) {
+				writer.println(ontRoot+getName(parent)+"."+refName + "List <T "  + ontRoot+"XML.ElementList");
+				writer.println(ontRoot+getName(parent)+".has"+refName + "List <R " +  ontRoot+getName(obj,"has")+"List : L0.FunctionalRelation");
+			} else {
+				writer.println(ontRoot+getName(parent)+"."+refName + "List <T "  + ontRoot+"XML.ElementList");
+				writer.println(ontRoot+getName(parent)+".has"+refName + "List <R " +  ontRoot+"XML.hasElementList : L0.FunctionalRelation");	
+			}
+		}
+	}
+	protected void handleIndicator(SchemaObject parent, SchemaElement indicator, SchemaElement element, boolean reference, String refName, OpenAttrs attrs) {
+		SchemaObject obj = getWithObj(parent, attrs);
+		writer.println(ontRoot+getName(parent)+".has"+refName + " <R " +  ontRoot+ getName(obj,"has"));
+		writer.println("   --> " + ontRoot+getName(obj));
+		if (useElementList(parent, indicator,element, reference, refName, new QName(obj.getName()))) {
+			writer.println(ontRoot+getName(parent)+"."+refName + "List <T "  + ontRoot+"XML.ElementList");
+			writer.println(ontRoot+getName(parent)+".has"+refName + "List <R " +  ontRoot+getName(obj,"has")+"List : L0.FunctionalRelation");
+		}
+	}
+	
+	@Override
+	protected void handleIndicator(SchemaObject parent, SchemaElement indicator, SchemaElement any) {
+		
+	}
+		
+	@Override
+	protected void handle(SchemaObject parent, Attribute attribute) {
+		String name = attribute.getName();
+		QName primitiveType = attribute.getType();
+		LocalSimpleType simpleType = attribute.getSimpleType();
+		QName ref = attribute.getRef();
+		
+		String relationName;
+		String relationType;
+		if (name != null) {
+			relationName = ontRoot+"has"+name;
+			if (parent != null)
+				relationName = ontRoot+getName(parent)+".has"+name;
+			relationType = ontRoot+"XML.hasAttribute";
+		}
+		else if (ref != null && parent != null) {
+			relationName = ontRoot+getName(parent)+".has"+ref.getLocalPart();
+			relationType = ontRoot+"has"+ref.getLocalPart();
+		} else {
+			throw new RuntimeException();
+		}
+		boolean id = false;
+		String ontType = null;
+		if (primitiveType != null) {
+			ontType = getL0TypeFromPrimitiveType(primitiveType);
+			if (ontType != null) {
+				id = getTypeEntry(primitiveType).id;
+				if (id)
+					relationType = ontRoot+"XML.hasID";
+			} else {
+				
+			}
+		} else if (simpleType != null){
+			Restriction restriction = simpleType.getRestriction();
+			if (restriction == null || simpleType.getUnion() != null || simpleType.getName() != null || simpleType.getId() != null)
+				throw new RuntimeException();
+			QName base = restriction.getBase();
+			
+			
+			ontType = getL0TypeFromPrimitiveType(base);
+			
+//			for (Object facetWrap : restriction.getFacets()) {
+//				JAXBElement<?> element = (JAXBElement<?>)facetWrap;
+//				QName elementName = element.getName();
+//				Facet facet = (Facet)element.getValue();	
+//			}
+		}
+			
+		
+		
+		writer.println(relationName+ " <R " + relationType + ": L0.FunctionalRelation");
+		if (id) {
+			// no need to add range restriction
+		} else if (ontType != null) {
+			writer.println("   --> " + ontType);
+		} else if (primitiveType != null) {
+			writer.println("   <R "+ontRoot+"has"+primitiveType.getLocalPart());
+		}
+	}
+	
+	@Override
+	protected void handleAttributes(SchemaObject simpleTypeObj) {
+//		SchemaObject parent = simpleTypeObj.getParent();
+//		SimpleType simpleType = simpleTypeObj.getSimpleType();
+//		Restriction restriction = simpleType.getRestriction();
+//		QName base = restriction.getBase();
+//		String ontType = getL0TypeFromPrimitiveType(base);
+	}
+	
+	@Override
+	protected void handle(SchemaObject parent, AttributeGroup attributeGroup) {
+		if (parent == null) {
+			NamedAttributeGroup group = (NamedAttributeGroup)attributeGroup;
+			writer.println(ontRoot+getAttributeGroupPrefix()+group.getName()+ " <T " + ontRoot +"XML.AttributeGroup");
+			SchemaObject obj = new SchemaObject(parent,attributeGroup);
+			for (Annotated annotated : group.getAttributeOrAttributeGroup()) {
+				if (annotated instanceof Attribute) {
+					//handle(getAttributeGroupPrefix()+group.getName(),(Attribute)annotated);
+					handle(obj,(Attribute)annotated);
+				} else if (annotated instanceof AttributeGroup) {
+					throw new RuntimeException("Cannot handle nested attribute groups");
+				}
+			}
+		} else {
+			writer.println(ontRoot+getName(parent) +" L0.Inherits " + ontRoot + getAttributeGroupPrefix() + attributeGroup.getRef().getLocalPart());
+		}
+		
+	}
+	
+	@Override
+	protected void handleAttributeComposition(SchemaObject parent, AttributeComposition composition, BijectionMap<org.simantics.xml.sax.configuration.Attribute, Annotated> attributes) {
+		Attribute compositionAttribute = new Attribute();
+		compositionAttribute.setName(composition.getName());
+		QName type = new QName(CONVERSION_NS, composition.getType());
+		compositionAttribute.setType(type);
+		handle(parent, compositionAttribute);
+	}
+	
+	@Override
+	protected void handleSimpleType(SchemaObject parent, SchemaObject simpleTypeObj) {
+		SimpleType simpleType = simpleTypeObj.getSimpleType();
+		String name = simpleType.getName();
+		Restriction restriction = simpleType.getRestriction();
+		if (restriction == null || simpleType.getUnion() != null || simpleType.getId() != null)
+			throw new RuntimeException();
+		QName base = restriction.getBase();
+		
+		String relationName = ontRoot+"has"+name;
+		if (parent != null)
+			relationName = ontRoot+getName(parent)+".has"+name;
+		
+		writer.println(relationName+ " <R "+ontRoot+"XML.hasAttribute : L0.FunctionalRelation");
+		
+		String ontType = getL0Type(base);
+		writer.println("   --> " + ontType);
+	}
+	
+	@Override
+	protected void handleComplexType(SchemaObject topLevelComplexType) {
+		String name = getName(topLevelComplexType);
+		if (name.contains("Pcurve"))
+			System.out.println();
+//		if (parent != null)
+//			name = parent +"_"+name;
+		
+		String relationName = ontRoot+getName(topLevelComplexType,"has");//ontRoot+"has"+name;
+		
+		writer.println(relationName+ " <R "+ontRoot+"XML.hasComplexType");
+		writer.println(relationName+ "List <R "+ontRoot+"XML.hasElementList");
+		//writer.println("   --> " + ontRoot+getComplexTypePrefix()+name);
+		writer.println("   --> " + ontRoot+name);
+		writer.println();
+		String baseType = ontRoot+"XML.ComplexType";
+
+		QName base = getComplexTypeBase(topLevelComplexType.getComplexType());
+		if (base != null) {
+			baseType = getType(base);
+		}
+		base = getSimpleTypeBase(topLevelComplexType.getSimpleType());
+		if (base != null) {
+			baseType = getType(base);
+		}
+		//writer.println(ontRoot+getComplexTypePrefix()+name+ " <T "+baseType);
+		writer.println(ontRoot+name+ " <T "+baseType);
+		super.handleComplexType(topLevelComplexType);
+		writer.println();
+	}
+	
+	@Override
+	protected void handleElement(SchemaObject elementObj) {
+		Element element = elementObj.getElement();
+		String name = getName(elementObj);//element.getName();
+
+//		if (parent != null)
+//			name = parent +"_"+name;
+		
+		String type = ontRoot+"XML.Element";
+		Set<String> types = new LinkedHashSet<String>();
+		if (element.getType() != null) {
+			types.add(getType(element.getType()));
+		}
+		QName base = getElementBase(element);
+		if (base != null) {
+			if (base.getNamespaceURI().equals(SCHEMA_NS)) {
+				String l0Type = getL0Type(base);
+				if (l0Type == null)
+					throw new RuntimeException("Cannot get L0 type for " + base.getLocalPart());
+				types.add(l0Type);
+			} else if (isElementRef(base.getLocalPart()))
+				types.add(ontRoot+base.getLocalPart());
+			else
+				types.add(ontRoot+getComplexTypePrefix()+base.getLocalPart());
+		}
+		QName substitution = element.getSubstitutionGroup();
+		if (substitution != null) {
+			if (isElementRef(substitution.getLocalPart()))
+				types.add(ontRoot+substitution.getLocalPart());
+			else
+				types.add( ontRoot+getComplexTypePrefix()+substitution.getLocalPart());
+		}
+		for (String t : types) {
+			type += " <T " + t;
+		}
+
+		String relationName =  ontRoot+getName(elementObj,"has");//ontRoot+"has"+name;
+//		if (elementObj.getParent() != null) {
+//			//relationName = ontRoot+getComplexTypePrefix()+"has"+name.substring(getComplexTypePrefix().length());
+//			relationName = ontRoot+getName(elementObj.getParent()) + "has"+element.getName();
+//		}
+		writer.println(relationName+ " <R "+ontRoot+"XML.hasElement");
+		writer.println(relationName+ "List <R "+ontRoot+"XML.hasElementList");
+		
+		writer.println(ontRoot+name+ " <T "+type);
+		
+		LocalComplexType complexType = element.getComplexType();
+		LocalSimpleType simpleType = element.getSimpleType();
+		
+		if (complexType != null) {
+			SchemaObject complexTypeObj = complexTypes.get(complexType);
+			handleElementComplexTypeAttributes(complexTypeObj);
+			handleComplexTypeExtension(complexTypeObj);
+		} else if (simpleType != null) {
+			SchemaObject simpleTypeObj = simpleTypes.get(simpleType);
+			handleElementSimpleTypeAttributes(simpleTypeObj);
+		}
+		
+		List<IDReference> references = getIDReferences(element);
+	
+		for (IDReference ref : references) {
+			writer.println(ontRoot+name+"."+ref.getReference().getName()+ " <R " +ontRoot+"XML.hasReference");
+		}
+		
+		writer.println();
+	}
+	
+	public static String getName(SchemaObject obj) {
+		if (obj.getParent() == null) {
+			switch (obj.getType()) {
+			case COMPLEX_TYPE:
+				return getComplexTypePrefix()+obj.getName();
+			case ELEMENT:
+				return obj.getName();
+			case ATTRIBUTE_GROUP:
+				return getAttributeGroupPrefix()+obj.getName();
+			case SIMPLE_TYPE:
+				return obj.getName();
+			}
+		} else {
+			SchemaObject o = obj;
+			SchemaObject prev = null;
+			String name = "";
+			while (o != null){
+				if (o.getName() != null)
+					name = o.getName()+"."+name;
+				prev = o;
+				o = o.getParent();
+			}
+			name = name.substring(0, name.length()-1);
+			switch (prev.getType()) {
+			case COMPLEX_TYPE:
+				return getComplexTypePrefix()+name;
+			case ELEMENT:
+				return name;
+			case ATTRIBUTE_GROUP:
+				return getAttributeGroupPrefix()+name;
+			case SIMPLE_TYPE:
+				return name;
+			}
+		}
+		throw new RuntimeException();
+		
+	}
+	
+	public static String getName(SchemaObject obj, String rel) {
+		if (obj.getParent() == null) {
+			switch (obj.getType()) {
+			case COMPLEX_TYPE:
+				return getComplexTypePrefix()+rel+obj.getName();
+			case ELEMENT:
+				return rel+obj.getName();
+			case ATTRIBUTE_GROUP:
+				return getAttributeGroupPrefix()+rel+obj.getName();
+			case SIMPLE_TYPE:
+				return rel+obj.getName();
+			}
+		} else {
+			SchemaObject o = obj;
+			SchemaObject prev = null;
+			String name = "";
+			while (o != null){
+				if (o.getName() != null)
+					name = o.getName()+"."+name;
+				prev = o;
+				o = o.getParent();
+			}
+			name = name.substring(0, name.length()-1);
+			switch (prev.getType()) {
+			case COMPLEX_TYPE:
+				return getComplexTypePrefix()+rel+name;
+			case ELEMENT:
+				return rel+name;
+			case ATTRIBUTE_GROUP:
+				return getAttributeGroupPrefix()+rel+name;
+			case SIMPLE_TYPE:
+				return rel+name;
+			}
+		}
+		throw new RuntimeException();
+		
+	}
+	
+	
+}