-package org.simantics.xml.sax.base;\r
-\r
-import java.util.HashMap;\r
-import java.util.HashSet;\r
-import java.util.Map;\r
-import java.util.Set;\r
-\r
-import javax.xml.stream.XMLStreamException;\r
-import javax.xml.stream.XMLStreamWriter;\r
-\r
-import org.simantics.db.ReadGraph;\r
-import org.simantics.db.Resource;\r
-import org.simantics.db.exception.DatabaseException;\r
-\r
-public abstract class XMLElementNamedChildWriterBase implements XMLElementNamedChildWriter{\r
-\r
- private Map<Resource,Class<? extends XMLElementWriter>> typeWriters = new HashMap<>();\r
- private Map<Resource,Class<? extends XMLElementWriter>> relationWriters = new HashMap<>();\r
- private Map<Resource,Map<Resource,Class<? extends XMLElementWriter>>> relationTypeWriters = new HashMap<>();\r
- private Set<Class<? extends XMLElementWriter>> writers = new HashSet<Class<? extends XMLElementWriter>>();\r
- \r
- \r
- public XMLElementNamedChildWriterBase() {\r
- \r
- }\r
- \r
- public XMLElementNamedChildWriterBase(ReadGraph graph) {\r
- \r
- }\r
- \r
- @Override\r
- public Resource getType(ReadGraph graph) throws DatabaseException {\r
- return null;\r
- }\r
- \r
- @Override\r
- public void start(ReadGraph graph, WriterElement instance, XMLStreamWriter writer) throws XMLStreamException {\r
- writer.writeStartElement(getElementId());\r
- }\r
- \r
- @Override\r
- public void characters(ReadGraph graph, WriterElement instance, XMLStreamWriter writer)\r
- throws XMLStreamException, DatabaseException {\r
- \r
- }\r
- \r
- @Override\r
- public void end(ReadGraph graph, WriterElement instance, XMLStreamWriter writer) throws XMLStreamException {\r
- writer.writeEndElement();\r
- }\r
- \r
- @Override\r
- public void children(ReadGraph graph, WriterElement instance, Set<Resource> sorted)\r
- throws XMLStreamException, DatabaseException {\r
- \r
- }\r
- \r
- @Override\r
- public Class<? extends XMLElementWriter> getWriter(ReadGraph graph, Map<Resource, XMLElementWriter> writers, WriterElement child) throws DatabaseException{\r
- Resource type = graph.getSingleType(child.instance);\r
- Class<? extends XMLElementWriter> writerClass = typeWriters.get(type);\r
- if (writerClass != null)\r
- return writerClass;\r
- if (child.statement != null) {\r
- Map<Resource,Class<? extends XMLElementWriter>> typeWriters = relationTypeWriters.get(child.statement.getPredicate());\r
- if (typeWriters != null) {\r
- writerClass = typeWriters.get(type);\r
- if (writerClass != null)\r
- return writerClass;\r
- }\r
- writerClass = relationWriters.get(child.statement.getPredicate());\r
- if (writerClass != null)\r
- return writerClass;\r
- }\r
- XMLElementWriter writer = writers.get(type);\r
- if (writer == null)\r
- return null;\r
- writerClass = writer.getClass();\r
- if (this.writers.contains(writerClass))\r
- return writerClass;\r
- for (Class<?> c : this.writers)\r
- if (c.isAssignableFrom(writerClass))\r
- return writerClass;\r
- return null;\r
- }\r
- \r
- public void addTypeWriter(Resource type, Class<? extends XMLElementWriter> writer) {\r
- typeWriters.put(type, writer);\r
- }\r
- \r
- public void addRelationWriter(Resource relation, Class<? extends XMLElementWriter> writer) {\r
- relationWriters.put(relation, writer);\r
- }\r
- \r
- public void addRelationTypeWriter(Resource relation, Resource type, Class<? extends XMLElementWriter> writer) {\r
- Map<Resource,Class<? extends XMLElementWriter>> typeWriters = relationTypeWriters.get(relation);\r
- if (typeWriters == null) {\r
- typeWriters = new HashMap<>();\r
- relationTypeWriters.put(relation, typeWriters);\r
- }\r
- typeWriters.put(type, writer);\r
- }\r
- \r
- \r
- public void addWriter(Class<? extends XMLElementWriter> writer) {\r
- writers.add(writer);\r
- }\r
-}\r
+package org.simantics.xml.sax.base;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamWriter;
+
+import org.simantics.db.ReadGraph;
+import org.simantics.db.Resource;
+import org.simantics.db.exception.DatabaseException;
+import org.simantics.xml.sax.ontology.XMLResource;
+
+public abstract class XMLElementNamedChildWriterBase implements XMLElementNamedChildWriter{
+
+ private Map<Resource,Class<? extends XMLElementWriter>> typeWriters = new HashMap<>();
+ private Map<Resource,Class<? extends XMLElementWriter>> relationWriters = new HashMap<>();
+ private Map<Resource,Map<Resource,Class<? extends XMLElementWriter>>> relationTypeWriters = new HashMap<>();
+ private Set<Class<? extends XMLElementWriter>> writers = new HashSet<Class<? extends XMLElementWriter>>();
+
+
+ public XMLElementNamedChildWriterBase() {
+
+ }
+
+ public XMLElementNamedChildWriterBase(ReadGraph graph) {
+
+ }
+
+ @Override
+ public Resource getType(ReadGraph graph) throws DatabaseException {
+ return null;
+ }
+
+ @Override
+ public void start(ReadGraph graph, WriterElement instance, XMLStreamWriter writer) throws XMLStreamException {
+ writer.writeStartElement(getElementId());
+ }
+
+ @Override
+ public void characters(ReadGraph graph, WriterElement instance, XMLStreamWriter writer)
+ throws XMLStreamException, DatabaseException {
+
+ }
+
+ @Override
+ public void end(ReadGraph graph, WriterElement instance, XMLStreamWriter writer) throws XMLStreamException {
+ writer.writeEndElement();
+ }
+
+ @Override
+ public void children(ReadGraph graph, WriterElement instance, Set<Resource> sorted)
+ throws XMLStreamException, DatabaseException {
+
+ }
+
+ @Override
+ public Class<? extends XMLElementWriter> getWriter(ReadGraph graph, Map<Resource, XMLElementWriter> writers, WriterElement child) throws DatabaseException{
+ //Resource type = graph.getSingleType(child.instance);
+ // hack fix for elements containing character data (Current schema conversion does not recognise such cases, leaving Literal type inheritance out).
+ XMLResource XML = XMLResource.getInstance(graph);
+ Resource type = graph.getSingleType(child.instance,XML.Element);
+ Class<? extends XMLElementWriter> writerClass = typeWriters.get(type);
+ if (writerClass != null)
+ return writerClass;
+ if (child.statement != null) {
+ Map<Resource,Class<? extends XMLElementWriter>> typeWriters = relationTypeWriters.get(child.statement.getPredicate());
+ if (typeWriters != null) {
+ writerClass = typeWriters.get(type);
+ if (writerClass != null)
+ return writerClass;
+ }
+ writerClass = relationWriters.get(child.statement.getPredicate());
+ if (writerClass != null)
+ return writerClass;
+ }
+ XMLElementWriter writer = writers.get(type);
+ if (writer == null)
+ return null;
+ writerClass = writer.getClass();
+ if (this.writers.contains(writerClass))
+ return writerClass;
+ for (Class<?> c : this.writers)
+ if (c.isAssignableFrom(writerClass))
+ return writerClass;
+ return null;
+ }
+
+ public void addTypeWriter(Resource type, Class<? extends XMLElementWriter> writer) {
+ typeWriters.put(type, writer);
+ }
+
+ public void addRelationWriter(Resource relation, Class<? extends XMLElementWriter> writer) {
+ relationWriters.put(relation, writer);
+ }
+
+ public void addRelationTypeWriter(Resource relation, Resource type, Class<? extends XMLElementWriter> writer) {
+ Map<Resource,Class<? extends XMLElementWriter>> typeWriters = relationTypeWriters.get(relation);
+ if (typeWriters == null) {
+ typeWriters = new HashMap<>();
+ relationTypeWriters.put(relation, typeWriters);
+ }
+ typeWriters.put(type, writer);
+ }
+
+
+ public void addWriter(Class<? extends XMLElementWriter> writer) {
+ writers.add(writer);
+ }
+}
private List<ParserElement> idReferenceElements = new ArrayList<ParserElement>();
- private
void loadElement(Deque<ParserElement> parents, ParserElement element) throws SAXException{
- loadElement(parents, element, true);
+ private
boolean loadElement(Deque<ParserElement> parents, ParserElement element) throws SAXException{
+ return loadElement(parents, element, true);
}
- private void loadElement(Deque<ParserElement> parents, ParserElement element, boolean checkParent) throws SAXException{
+ private boolean loadElement(Deque<ParserElement> parents, ParserElement element, boolean checkParent) throws SAXException{
XMLElementParser parser = null;
ParserElement parent = null;
if (parents.size() > 0) {
if (checkParent && parent.getXMLParser() != null && parent.getXMLParser() != this) {
//element.setXMLParser(parent.getXMLParser());
element.setXMLParser(parent.getXMLParser());
- parent.getXMLParser().loadElement(parents, element);
- return;
+ if (parent.getXMLParser().loadElement(parents, element))
+ return true;
}
if (parent.getElementParser() instanceof XMLElementNamedChildParser) {
// use parent's named child parser if it is supported
if (parser instanceof IDReferenceParser)
idReferenceElements.add(element);
element.setElementParser(parser);
+ return true;
} catch (DatabaseException e) {
throw new SAXException(e);
}
String nsRef[] = element.getQName().split(":");
if (schemaRef != null && subParsers.containsKey(schemaRef.value)) {
XMLParser subParser = subParsers.get(schemaRef.value);
- subParser.loadElement(parents, element);
+ boolean b = subParser.loadElement(parents, element);
element.setXMLParser(subParser);
+ return b;
} else if (nsRef.length == 2 && element.getNS(nsRef[0]) != null && subParsers.containsKey(element.getNS(nsRef[0]))) {
XMLParser subParser = subParsers.get(element.getNS(nsRef[0]));
- subParser.loadElement(parents, element, false);
+ boolean b = subParser.loadElement(parents, element, false);
element.setXMLParser(subParser);
+ return b;
} else {
if (parent == null && parents.size() > 0)
parent = parents.peek();
logger.log(new Status(IStatus.ERROR, PLUGIN_ID, err));
if (debug) System.err.println(err);
+ return false;
}
}
}
-package org.simantics.xml.sax.base;\r
-\r
-import java.lang.reflect.Constructor;\r
-import java.lang.reflect.InvocationTargetException;\r
-import java.util.HashMap;\r
-import java.util.HashSet;\r
-import java.util.LinkedHashSet;\r
-import java.util.List;\r
-import java.util.Map;\r
-import java.util.Set;\r
-\r
-import javax.xml.stream.XMLStreamException;\r
-import javax.xml.stream.XMLStreamWriter;\r
-\r
-import org.eclipse.core.runtime.IStatus;\r
-import org.eclipse.core.runtime.Status;\r
-import org.simantics.db.ReadGraph;\r
-import org.simantics.db.Resource;\r
-import org.simantics.db.Statement;\r
-import org.simantics.db.common.utils.ListUtils;\r
-import org.simantics.db.common.utils.NameUtils;\r
-import org.simantics.db.exception.DatabaseException;\r
-import org.simantics.layer0.Layer0;\r
-import org.simantics.message.ILogger;\r
-import org.simantics.xml.sax.ontology.XMLResource;\r
-\r
-public class XMLWriter {\r
- \r
- public static String XML_SCHEMA_URI = "http://www.w3.org/2001/XMLSchema";\r
- public static String XML_SCHEMA_INSTANCE_URI = "http://www.w3.org/2001/XMLSchema-instance";\r
- \r
- private ReadGraph graph;\r
- private Map<Resource, XMLWriter> subWriters = new HashMap<Resource, XMLWriter>();\r
- private Map<Class<? extends XMLElementWriter>, XMLElementWriter> namedWriters = new HashMap<Class<? extends XMLElementWriter>, XMLElementWriter>();\r
- private Map<Resource,XMLElementWriter> writers = new HashMap<>();\r
- private String schemaURI;\r
- private String ontologyURI;\r
- private Resource ontology;\r
- \r
- private ILogger logger;\r
- \r
- public ReadGraph getGraph() {\r
- return graph;\r
- }\r
- \r
- public void setGraph(ReadGraph graph) throws DatabaseException {\r
- this.graph = graph;\r
- for (XMLWriter p : subWriters.values())\r
- p.setGraph(graph);\r
- if (ontologyURI != null)\r
- this.ontology = graph.getResource(ontologyURI);\r
- }\r
- \r
- public String getSchemaURI() {\r
- return schemaURI;\r
- }\r
- \r
- public void setSchemaURI(String schemaURI) {\r
- this.schemaURI = schemaURI;\r
- }\r
- \r
- public String getOntologyURI() {\r
- return ontologyURI;\r
- }\r
- \r
- public void setOntologyURI(String ontologyURI) {\r
- this.ontologyURI = ontologyURI;\r
- }\r
- \r
- public Resource getOntology() {\r
- return ontology;\r
- }\r
- \r
- public void add(XMLElementWriter writer) throws DatabaseException {\r
- Resource type = writer.getType(graph);\r
- if (type != null)\r
- writers.put(type, writer);\r
- namedWriters.put(writer.getClass(), writer);\r
- }\r
- \r
- public void add(XMLWriter writer) {\r
- subWriters.put(writer.getOntology(), writer);\r
- }\r
- \r
- public void write(Resource root, XMLStreamWriter writer) throws DatabaseException, XMLStreamException {\r
- WriterElement element = new WriterElement(root);\r
- loadElement(element);\r
- write(element, writer);\r
- }\r
- \r
- \r
- protected void write(WriterElement instance, XMLStreamWriter writer) throws DatabaseException, XMLStreamException {\r
- XMLResource XML = XMLResource.getInstance(graph);\r
-\r
- XMLElementWriter elementWriter = instance.writer;\r
- elementWriter.start(graph, instance, writer);\r
- if (instance.parent == null) {\r
- if(getSchemaURI() != null) {\r
- writer.writeDefaultNamespace(getSchemaURI());\r
- }\r
- writer.writeNamespace("xsd", XML_SCHEMA_URI);\r
- writer.writeNamespace("xsi", XML_SCHEMA_INSTANCE_URI);\r
- }\r
- elementWriter.attributes(graph, instance, graph.getStatements(instance.instance, XML.hasAttribute), writer);\r
- if (graph.hasValue(instance.instance))\r
- elementWriter.characters(graph, instance, writer);\r
- // get all child elements\r
- Set<Statement> childElements = new HashSet<>();\r
- childElements.addAll(graph.getStatements(instance.instance, XML.hasElement));\r
- childElements.addAll(graph.getStatements(instance.instance, XML.hasComplexType));\r
- // load elements, assign writers\r
- Map<Resource,WriterElement> elementMap = new HashMap<>();\r
- for (Statement s : childElements) {\r
- WriterElement c = new WriterElement(instance,s);\r
- loadElement(c);\r
- elementMap.put(s.getObject(), c);\r
- }\r
- LinkedHashSet<Resource> sorted = new LinkedHashSet<>();\r
- if (graph.hasStatement(instance.instance, XML.hasOriginalElementList)) {\r
- Resource originalList = graph.getSingleObject(instance.instance, XML.hasOriginalElementList);\r
- List<Resource> l = ListUtils.toList(graph, originalList);\r
- sorted.addAll(l);\r
- }\r
- elementWriter.children(graph, instance, sorted);\r
- Set<Resource> processed = new HashSet<>();\r
- for (Resource r : sorted) {\r
- if (processed.contains(r)) // badly generated writer could report elements several times. \r
- continue;\r
- WriterElement child = elementMap.get(r);\r
- if (child == null)\r
- throw new DatabaseException("Trying to export unregonized resource " +NameUtils.getSafeName(graph, r) + " " + r);\r
- write(child, writer);\r
- processed.add(r);\r
- }\r
- //write the rest of the elements (in random order) \r
- for (Statement stm : childElements) {\r
- if (processed.contains(stm.getObject()))\r
- continue;\r
- WriterElement child = elementMap.get(stm.getObject());\r
- if (child == null)\r
- throw new DatabaseException("Trying to export unregonized resource " +NameUtils.getSafeName(graph, stm.getObject()) + " " + stm.getObject());\r
- write(child, writer);\r
- }\r
- \r
- elementWriter.end(graph, instance, writer);\r
- \r
- }\r
- \r
- private void loadElement(WriterElement child) throws DatabaseException {\r
- XMLElementWriter childWriter = null;\r
- if (child.parent != null && child.parent.writer instanceof XMLElementNamedChildWriter) {\r
- XMLElementNamedChildWriter namedParentWriter = (XMLElementNamedChildWriter)child.parent.writer;\r
- Class<? extends XMLElementWriter> childWriterClass = namedParentWriter.getWriter(graph, writers, child);\r
- if (childWriterClass != null) {\r
- childWriter = this.writers.get(childWriterClass);\r
- if (childWriter == null) {\r
- try {\r
- Constructor<? extends XMLElementWriter> c = null;\r
- try {\r
- c = childWriterClass.getConstructor(ReadGraph.class);\r
- childWriter = c.newInstance(graph);\r
- } catch (NoSuchMethodException e) {\r
- c = childWriterClass.getConstructor();\r
- childWriter = c.newInstance();\r
- }\r
- namedWriters.put(childWriterClass, childWriter);\r
- } catch (IllegalAccessException|InstantiationException|NoSuchMethodException|SecurityException|InvocationTargetException e) {\r
- String err = "Error processing " + childWriterClass.getName() + " : element writers must have accessible constructor with ReadGraph parameter";\r
- logger.log(new Status(IStatus.ERROR, XMLParser.PLUGIN_ID, err, e));\r
- } \r
- }\r
- }\r
- } else {\r
- Resource type = graph.getSingleType(child.instance);\r
- childWriter = writers.get(type);\r
- }\r
- if (childWriter == null) {\r
- // try child ontology/schema\r
- Resource type = graph.getSingleType(child.instance);\r
- Resource ontology = getOntology(type);\r
- if (ontology != null) {\r
- XMLWriter xmlWriter = subWriters.get(ontology);\r
- if (xmlWriter != null) {\r
- childWriter = xmlWriter.writers.get(type);\r
- // wrap the child writer with namespace writer\r
- if (childWriter != null) {\r
- if (childWriter instanceof XMLElementNamedChildWriter) {\r
- childWriter = new XMLNSNamedChildWriter((XMLElementNamedChildWriter)childWriter, xmlWriter.schemaURI);\r
- } else {\r
- childWriter = new XMLNSElementWriter(childWriter, xmlWriter.schemaURI);\r
- }\r
- }\r
- }\r
- }\r
- if (childWriter == null)\r
- throw new DatabaseException("Cannot locate writer for " + NameUtils.getSafeName(graph, child.instance) + ", " + child.instance);\r
- }\r
- child.writer = childWriter;\r
- \r
- }\r
- \r
- private Resource getOntology(Resource type) throws DatabaseException {\r
- Layer0 L0 = Layer0.getInstance(graph);\r
- Resource r = type;\r
- while (true) {\r
- r = graph.getPossibleObject(r, L0.PartOf);\r
- if (r != null && graph.isInstanceOf(r, L0.Ontology))\r
- break;\r
- }\r
- return r;\r
- }\r
-\r
-}\r
+package org.simantics.xml.sax.base;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamWriter;
+
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.Status;
+import org.simantics.db.ReadGraph;
+import org.simantics.db.Resource;
+import org.simantics.db.Session;
+import org.simantics.db.Statement;
+import org.simantics.db.common.utils.ListUtils;
+import org.simantics.db.common.utils.NameUtils;
+import org.simantics.db.exception.DatabaseException;
+import org.simantics.layer0.Layer0;
+import org.simantics.message.ILogger;
+import org.simantics.xml.sax.ontology.XMLResource;
+
+public class XMLWriter {
+
+ public static String XML_SCHEMA_URI = "http://www.w3.org/2001/XMLSchema";
+ public static String XML_SCHEMA_INSTANCE_URI = "http://www.w3.org/2001/XMLSchema-instance";
+
+ private ReadGraph graph;
+ private Map<Resource, XMLWriter> subWriters = new HashMap<Resource, XMLWriter>();
+ private Map<Class<? extends XMLElementWriter>, XMLElementWriter> namedWriters = new HashMap<Class<? extends XMLElementWriter>, XMLElementWriter>();
+ private Map<Resource,XMLElementWriter> writers = new HashMap<>();
+ private String schemaURI;
+ private String ontologyURI;
+ private Resource ontology;
+
+ private ILogger logger;
+
+ protected Map<String,String> nsPrefixes;
+
+ public ReadGraph getGraph() {
+ return graph;
+ }
+
+ public void setGraph(ReadGraph graph) throws DatabaseException {
+ this.graph = graph;
+ for (XMLWriter p : subWriters.values())
+ p.setGraph(graph);
+ if (ontologyURI != null)
+ this.ontology = graph.getResource(ontologyURI);
+ }
+
+ public String getSchemaURI() {
+ return schemaURI;
+ }
+
+ public void setSchemaURI(String schemaURI) {
+ this.schemaURI = schemaURI;
+ }
+
+ public String getOntologyURI() {
+ return ontologyURI;
+ }
+
+ public void setOntologyURI(String ontologyURI) {
+ this.ontologyURI = ontologyURI;
+ }
+
+ public Resource getOntology() {
+ return ontology;
+ }
+
+ public void add(XMLElementWriter writer) throws DatabaseException {
+ Resource type = writer.getType(graph);
+ if (type != null)
+ writers.put(type, writer);
+ namedWriters.put(writer.getClass(), writer);
+ }
+
+ public void add(XMLWriter writer) {
+ subWriters.put(writer.getOntology(), writer);
+ }
+
+ public void configureWriter(XMLStreamWriter writer) throws XMLStreamException {
+ if (nsPrefixes == null)
+ return;
+ for (Entry<String, String> nsEntry : nsPrefixes.entrySet()) {
+ writer.setPrefix(nsEntry.getValue(), nsEntry.getKey());
+ }
+
+ }
+
+ public void writeNS(XMLStreamWriter writer) throws XMLStreamException {
+ if (nsPrefixes == null)
+ return;
+ for (Entry<String, String> nsEntry : nsPrefixes.entrySet()) {
+ writer.writeNamespace(nsEntry.getValue(), nsEntry.getKey());
+ }
+
+ }
+
+ public XMLWriter resolveDependencies(Session session) throws DatabaseException {
+ java.util.Map<String, XMLWriter> map = new java.util.HashMap<>();
+ map.put(this.schemaURI, this);
+ addDependencies(session,map);
+ nsPrefixes = new HashMap<>();
+ int i = 0;
+ for (String ns : map.keySet()) {
+ if (this.schemaURI.equals(ns))
+ continue;
+ if (!nsPrefixes.containsKey(ns)) {
+ nsPrefixes.put(ns, "ns"+i);
+ i++;
+ }
+ }
+ return this;
+ }
+
+ public void addDependencies(Session session,java.util.Map<String,XMLWriter> map) throws DatabaseException {
+
+ }
+
+ public void write(Resource root, XMLStreamWriter writer) throws DatabaseException, XMLStreamException {
+ WriterElement element = new WriterElement(root);
+ loadElement(element);
+ write(element, writer);
+ }
+
+
+ protected void write(WriterElement instance, XMLStreamWriter writer) throws DatabaseException, XMLStreamException {
+ XMLResource XML = XMLResource.getInstance(graph);
+
+ XMLElementWriter elementWriter = instance.writer;
+ elementWriter.start(graph, instance, writer);
+ if (instance.parent == null) {
+ if(getSchemaURI() != null) {
+ writer.writeDefaultNamespace(getSchemaURI());
+ }
+ writer.writeNamespace("xsd", XML_SCHEMA_URI);
+ writer.writeNamespace("xsi", XML_SCHEMA_INSTANCE_URI);
+ this.configureWriter(writer);
+ this.writeNS(writer);
+ }
+
+ elementWriter.attributes(graph, instance, graph.getStatements(instance.instance, XML.hasAttribute), writer);
+ if (graph.hasValue(instance.instance))
+ elementWriter.characters(graph, instance, writer);
+ // get all child elements
+ Set<Statement> childElements = new HashSet<>();
+ childElements.addAll(graph.getStatements(instance.instance, XML.hasElement));
+ childElements.addAll(graph.getStatements(instance.instance, XML.hasComplexType));
+ // load elements, assign writers
+ Map<Resource,WriterElement> elementMap = new HashMap<>();
+ for (Statement s : childElements) {
+ WriterElement c = new WriterElement(instance,s);
+ loadElement(c);
+ elementMap.put(s.getObject(), c);
+ }
+ LinkedHashSet<Resource> sorted = new LinkedHashSet<>();
+ if (graph.hasStatement(instance.instance, XML.hasOriginalElementList)) {
+ Resource originalList = graph.getSingleObject(instance.instance, XML.hasOriginalElementList);
+ List<Resource> l = ListUtils.toList(graph, originalList);
+ sorted.addAll(l);
+ }
+ elementWriter.children(graph, instance, sorted);
+ Set<Resource> processed = new HashSet<>();
+ for (Resource r : sorted) {
+ if (processed.contains(r)) // badly generated writer could report elements several times.
+ continue;
+ WriterElement child = elementMap.get(r);
+ if (child == null)
+ throw new DatabaseException("Trying to export unregonized resource " +NameUtils.getSafeName(graph, r) + " " + r);
+ write(child, writer);
+ processed.add(r);
+ }
+ //write the rest of the elements (in random order)
+ for (Statement stm : childElements) {
+ if (processed.contains(stm.getObject()))
+ continue;
+ WriterElement child = elementMap.get(stm.getObject());
+ if (child == null)
+ throw new DatabaseException("Trying to export unregonized resource " +NameUtils.getSafeName(graph, stm.getObject()) + " " + stm.getObject());
+ write(child, writer);
+ }
+
+ elementWriter.end(graph, instance, writer);
+
+ }
+
+ private void loadElement(WriterElement child) throws DatabaseException {
+ if (child.instance.getResourceId() == 983084L)
+ System.out.println();
+ XMLElementWriter childWriter = null;
+ if (child.parent != null && child.parent.writer instanceof XMLElementNamedChildWriter) {
+ XMLElementNamedChildWriter namedParentWriter = (XMLElementNamedChildWriter)child.parent.writer;
+ Class<? extends XMLElementWriter> childWriterClass = namedParentWriter.getWriter(graph, writers, child);
+ if (childWriterClass != null) {
+ childWriter = this.writers.get(childWriterClass);
+ if (childWriter == null) {
+ try {
+ Constructor<? extends XMLElementWriter> c = null;
+ try {
+ c = childWriterClass.getConstructor(ReadGraph.class);
+ childWriter = c.newInstance(graph);
+ } catch (NoSuchMethodException e) {
+ c = childWriterClass.getConstructor();
+ childWriter = c.newInstance();
+ }
+ namedWriters.put(childWriterClass, childWriter);
+ } catch (IllegalAccessException|InstantiationException|NoSuchMethodException|SecurityException|InvocationTargetException e) {
+ String err = "Error processing " + childWriterClass.getName() + " : element writers must have accessible constructor with ReadGraph parameter";
+ logger.log(new Status(IStatus.ERROR, XMLParser.PLUGIN_ID, err, e));
+ }
+ }
+ }
+ } else {
+ Resource type = graph.getSingleType(child.instance);
+ childWriter = writers.get(type);
+ }
+ if (childWriter == null) {
+ // try child ontology/schema
+ //Resource type = graph.getSingleType(child.instance);
+ // hack fix for elements containing character data (Current schema conversion does not recognise such cases, leaving Literal type inheritance out).
+ XMLResource XML = XMLResource.getInstance(graph);
+ Resource type = graph.getSingleType(child.instance,XML.Element);
+ Resource ontology = getOntology(type);
+ if (ontology != null) {
+ XMLWriter xmlWriter = subWriters.get(ontology);
+ if (xmlWriter == null) {
+ // FIXME: We need better way to resolve correct ontology and writer.
+ for (XMLWriter w : subWriters.values()) {
+ xmlWriter = w.subWriters.get(ontology);
+ if (xmlWriter != null)
+ break;
+ }
+ }
+ if (xmlWriter != null) {
+ childWriter = xmlWriter.writers.get(type);
+ // wrap the child writer with namespace writer
+ if (childWriter != null) {
+ if (childWriter instanceof XMLElementNamedChildWriter) {
+ childWriter = new XMLNSNamedChildWriter((XMLElementNamedChildWriter)childWriter, xmlWriter.schemaURI);
+ } else {
+ childWriter = new XMLNSElementWriter(childWriter, xmlWriter.schemaURI);
+ }
+ }
+ }
+ }
+ if (childWriter == null)
+ throw new DatabaseException("Cannot locate writer for " + NameUtils.getSafeName(graph, child.instance) + ", " + child.instance);
+ }
+ child.writer = childWriter;
+
+ }
+
+ private Resource getOntology(Resource type) throws DatabaseException {
+ Layer0 L0 = Layer0.getInstance(graph);
+ Resource r = type;
+ while (true) {
+ r = graph.getPossibleObject(r, L0.PartOf);
+ if (r != null && graph.isInstanceOf(r, L0.Ontology))
+ break;
+ }
+ return r;
+ }
+
+}
} else {
schemaElement = elementMap.get(s).get(elementName);
}
- if (elementName.equals("CanvasLayers.TracingLayer") || elementName.equals("Layer"))
- System.out.println();
Element parentElement = elementStack.peek();
boolean newElement = false;
boolean sameNameSpace = true;
if (parentElement != null) {
- //QName parentType = parentElement.getType();
String parentNs = elementNsMap.get(parentElement);
sameNameSpace =currentNS.equals(parentNs);
if (!sameNameSpace) {
}
if (schemaElement == null) {
-
- //QName type = null;
if (elementStack.isEmpty()) {
schemaElement = new TopLevelElement();
s.getSimpleTypeOrComplexTypeOrGroup().add(schemaElement);
} else {
-
-
-// if (sameNameSpace) {
-// localElement = new LocalElement();
-// schemaElement = localElement;
-// //type = new QName(elementName);
-//
-// } else {
- schemaElement = new TopLevelElement();
- s.getSimpleTypeOrComplexTypeOrGroup().add(schemaElement);
- //type = new QName(SchemaConversionBase.SCHEMA_NS,"element");
-
-
-// }
+ schemaElement = new TopLevelElement();
+ s.getSimpleTypeOrComplexTypeOrGroup().add(schemaElement);
}
schemaElement.setName(elementName);
elementNsMap.put(schemaElement, currentNS);
Attribute attribute = attributeIterator.next();
if ("http://www.w3.org/XML/1998/namespace".equals(attribute.getName().getNamespaceURI()))
continue;
- addAttribute(attribute, complexType, parseElement.getNamespaceURI(attribute.getName().getPrefix()));
+ addAttribute(attribute, complexType, currentNS);
}
} else {
continue;
org.w3._2001.xmlschema.Attribute schemaAttribute = currentAttributes.get(attribute.getName().getLocalPart());
if (schemaAttribute == null) {
- addAttribute(attribute, complexType, parseElement.getNamespaceURI(attribute.getName().getPrefix()));
+ addAttribute(attribute, complexType, currentNS);
} else {
QName newType = getType(attribute.getValue());
updateAttributeType(schemaAttribute, newType);
// System.out.println("End " + element.getName());
elementStack.pop();
} else if (event.isAttribute()) {
- System.out.println(event);
+
} else if (event.isStartDocument()) {
- System.out.println(event);
+
} else if (event.isEndDocument()) {
} else if (event.isEntityReference()) {
// if (!characters.isWhiteSpace())
// System.out.println(characters.getData());
} else if (event.isNamespace()) {
- System.out.println(event);
+
}
}
}
}
private void addAttribute(Attribute attribute, ComplexType complexType, String currentNS) {
- if (attribute.getName().getLocalPart().equals("Panel.ZIndex"))
- System.out.println();
if (attribute.getName().getNamespaceURI().length() == 0 || attribute.getName().getNamespaceURI().equals(currentNS)) {
org.w3._2001.xmlschema.Attribute schemaAttribute = new org.w3._2001.xmlschema.Attribute();
schemaAttribute.setName(attribute.getName().getLocalPart());
}
}
}
- if ("Panel.ZIndex".equals(schemaAttribute.getName()))
- System.out.println();
complexType.getAttributeOrAttributeGroup().add(schemaAttribute);
}
mainWriter.println();
mainWriter.println(" public " + name + importerClassPostfix+"(Session session, File file, Resource root) throws DatabaseException {");
mainWriter.println(" super(session, file, root);");
- mainWriter.println(" setXmlWriter(new "+name + parserClassPostfix+"(session));");
+ mainWriter.println(" setXmlWriter(new "+name + parserClassPostfix+"(session).resolveDependencies(session));");
mainWriter.println(" }");
mainWriter.println();
mainWriter.println("}");
mainWriter.println(" }");
mainWriter.println(" });");
mainWriter.println(" }");
+
+ mainWriter.println();
+ if (converter.getSubConverters().size() > 0) {
+ mainWriter.println(" public void addDependencies(org.simantics.db.Session session, java.util.Map<String,XMLWriter> map) throws DatabaseException {");
+ for (SchemaConverter sc : converter.getSubConverters()) {
+ String s = sc.className;
+ if (s.endsWith("Ontology"))
+ s = s.substring(0,s.length()-"Ontology".length());
+ s +="Writer";
+ mainWriter.println(" {");
+ mainWriter.println(" XMLWriter parser = new "+s+"(session);");
+ mainWriter.println(" if (!map.containsKey(parser.getSchemaURI())) {");
+ mainWriter.println(" map.put(parser.getSchemaURI(), parser);");
+ mainWriter.println(" parser.addDependencies(session,map);");
+ mainWriter.println(" } else {");
+ mainWriter.println(" parser = map.get(parser.getSchemaURI());");
+ mainWriter.println(" }");
+ mainWriter.println(" add(parser);");
+ mainWriter.println(" }");
+ }
+ mainWriter.println(" }");
+
+ mainWriter.println(" public XMLWriter resolveDependencies(org.simantics.db.Session session) throws DatabaseException {");
+ mainWriter.println(" super.resolveDependencies(session);");
+ for (SchemaConverter sc : converter.getSubConverters()) {
+ String s = sc.schemaNs;
+ mainWriter.println(" if (!nsPrefixes.containsKey(\""+s+"\")) {");
+ mainWriter.println(" nsPrefixes.put(\""+s+"\", \"ns\"+nsPrefixes.size());");
+ mainWriter.println(" }");
+ }
+ mainWriter.println(" return this;");
+ mainWriter.println(" }");
+ }
mainWriter.println("}");
mainWriter.println();
protected void createReferenceIndicator(SchemaObject parent, RefType referenceType, String refName, String objectName,
String primaryClassName, String secondaryClassName, boolean useElementList, boolean useOriginalList) {
FileWriter fw = getWriter(parent);
- if ("TextOrField".equals(refName))
- System.out.println();
if (referenceType == RefType.Type) {
// create internal class for handling the element and child attachment
secondaryClassName = getName(parent) +"_" +objectName;
String relationName;
String attrName;
+ String ns = null;
if (name != null) {
attrName = name;
relationName = ontShort+"has"+base.getName(attribute);
if (referred != null) {
primitiveType = referred.getType();
simpleType = referred.getSimpleType();
+ if (ref.getNamespaceURI() != null && !ref.getNamespaceURI().equals(this.converter.schemaNs))
+ ns = ref.getNamespaceURI();
}
} else {
TypeEntry binding = base.getTypeEntry(primitiveType);
if (binding != null) {
- writeAttribute(fw, attrName, relationName, binding, isReference);
+ if (ns != null)
+ writeAttribute(fw, ns, attrName, relationName, binding, isReference);
+ else
+ writeAttribute(fw, attrName, relationName, binding, isReference);
return;
} else {
if (simpleType == null) {
}
}
}
+
if (simpleType != null) {
org.w3._2001.xmlschema.List list = simpleType.getList();
if (list != null) {
//String binding = getBindingFromPrimitiveType(base);
TypeEntry binding = this.base.getTypeEntry(base);
- writeAttribute(fw, attrName, relationName, binding, isReference);
+ if (base.getNamespaceURI() != null)
+ writeAttribute(fw, base.getNamespaceURI(), attrName, relationName, binding, isReference);
+ else
+ writeAttribute(fw, attrName, relationName, binding, isReference);
}
} else {
// TODO : using default String attribute should be configured with rules.
fw.writer.println(" }");
}
+ private void writeAttribute(FileWriter fw, String ns, String attrName, String relationName, TypeEntry binding, boolean isReference) {
+ fw.writer.println(" {");
+ fw.writer.println(" if (attribute.getPredicate().equals("+relationName+")) {");
+ fw.writer.println(" writer.writeAttribute(\""+ns+"\",\""+attrName+"\", " + binding.getToString("graph.getValue(attribute.getObject(),"+binding.binding+")")+");");
+ // fw.writer.println(" graph.claimLiteral(element.getData(),"+relationName+","+getValueGetterMethod(binding,"a")+", "+binding.binding+");");
+ // if (isReference)
+ // fw.writer.println(" idProviderValue = a.getValue();");
+ fw.writer.println(" }");
+ fw.writer.println(" }");
+ }
+
@Override
public void handleAttributes(SchemaObject simpleTypeObj) {
SchemaObject parent = simpleTypeObj.getParent();
@Override
public void createReferenceIndicator(SchemaObject parent, RefType referenceType, String refName, String objectName, String primaryClassName, String secondaryClassName, boolean useElementList, boolean useOriginalList) {
- if (refName == null)
- System.out.println();
+// if (refName == null)
+// System.out.println();
FileWriter fw = getWriter(parent);
if (referenceType == RefType.Type) {
// create internal class for handling the element and child attachment
@Override
protected void createElementIndicator(SchemaObject parent, boolean useElementList, String refName, String className, boolean useOriginalList) {
- if (refName == null)
- System.out.println();
+// if (refName == null)
+// System.out.println();
FileWriter fw = getWriter(parent);
//if (!reference)
fw.writer.println(" addParser(\""+ refName +"\", "+className+".class);");
}
}
//dd
- if(true)
- System.out.println();
fw.writer.println(commentTag+" End of AttributeGroup " + group.getName());
}
}
-
-
-
-
-
-
+
IDProvider provider;
@Override
public void handleElement(SchemaObject elementObj) {
private Map<String,SchemaObject> complexTypeName = new HashMap<>();
private Map<String,SchemaObject> simpleTypeName = new HashMap<>();
private Map<String,SchemaObject> modelGroupName = new HashMap<>();
+ private Map<String,SchemaObject> attrName = new HashMap<>();
private Map<Element,SchemaObject> elements = new HashMap<>();
private Map<ComplexType,SchemaObject> complexTypes = new HashMap<>();
private Map<SimpleType,SchemaObject> simpleTypes = new HashMap<>();
private Map<NamedGroup,SchemaObject> modelGroups = new HashMap<>();
+ private Map<Attribute,SchemaObject> attributes = new HashMap<>();
private SchemaObject _getWithName(QName name) {
SchemaObject obj = elementName.get(name.getLocalPart());
obj = complexTypeName.get(name.getLocalPart());
if (obj == null)
obj = simpleTypeName.get(name.getLocalPart());
+ if (obj == null)
+ obj = attrName.get(name.getLocalPart());
return obj;
}
SchemaObject obj = new SchemaObject(this,simpleType);
stack.push(obj);
} else if (attrs instanceof Attribute) {
- // Attributes are not cached
+ Attribute attribute = (Attribute)attrs;
+ SchemaObject obj = new SchemaObject(this, attribute);
+ stack.push(obj);
} else if (attrs instanceof AttributeGroup) {
// Attribute groups are not cached
} else if (attrs instanceof NamedGroup) {
modelGroups.put(e, object);
break;
}
+ case ATTRIBUTE: {
+ Attribute e = object.getAttribute();
+ attrName.put(e.getName(), object);
+ attributes.put(e, object);
+ break;
+ }
}
} // while
}
return type;
}
+ private SchemaObject _getAttribute(QName name) {
+ return attrName.get(name.getLocalPart());
+ }
+
protected Attribute getRefAttribute(QName ref) {
- for (OpenAttrs attrs : schema.getSimpleTypeOrComplexTypeOrGroup()) {
- if (attrs instanceof TopLevelAttribute) {
- TopLevelAttribute attribute = (TopLevelAttribute)attrs;
- if (attribute.getName().equals(ref.getLocalPart()))
- return attribute;
- }
+// for (OpenAttrs attrs : schema.getSimpleTypeOrComplexTypeOrGroup()) {
+// if (attrs instanceof TopLevelAttribute) {
+// TopLevelAttribute attribute = (TopLevelAttribute)attrs;
+// if (attribute.getName().equals(ref.getLocalPart()))
+// return attribute;
+// }
+// }
+ SchemaObject obj = _getAttribute(ref);
+ if (obj != null)
+ return obj.getAttribute();
+ if (ref.getNamespaceURI() != null) {
+ for (SchemaConverter sc : converter.getConverter(ref.getNamespaceURI())) {
+ if (sc.base != null) {
+ obj = sc.base._getAttribute(ref);
+ if (obj != null) {
+ return obj.getAttribute();
+ }
+ }
+ }
}
return null;
}
package org.simantics.xml.sax;
import org.simantics.xml.sax.configuration.Rename;
+import org.w3._2001.xmlschema.Attribute;
import org.w3._2001.xmlschema.AttributeGroup;
import org.w3._2001.xmlschema.AttributeGroupRef;
import org.w3._2001.xmlschema.ComplexType;
import org.w3._2001.xmlschema.SimpleType;
public class SchemaObject {
- enum ObjectType{ELEMENT,COMPLEX_TYPE,SIMPLE_TYPE,ATTRIBUTE_GROUP,MODEL_GROUP};
+ enum ObjectType{ELEMENT,COMPLEX_TYPE,SIMPLE_TYPE,ATTRIBUTE_GROUP,MODEL_GROUP,ATTRIBUTE};
private SchemaConversionBase sc;
private String name;
this(sc,null, namedGroup);
}
+ public SchemaObject(SchemaConversionBase sc, Attribute attribute) {
+ this(sc,null, attribute);
+ }
+
public SchemaObject(SchemaConversionBase sc,SchemaObject parent, Element element) {
this.parent = parent;
this.obj = element;
_init();
}
+ public SchemaObject(SchemaConversionBase sc,SchemaObject parent, Attribute attribute) {
+ this.parent = parent;
+ this.obj = attribute;
+ this.type = ObjectType.ATTRIBUTE;
+ this.sc = sc;
+ _init();
+ }
+
private void _init() {
name = _getName();
if (name != null)
return (NamedGroup)obj;
}
+ public Attribute getAttribute() {
+ if (type != ObjectType.ATTRIBUTE)
+ return null;
+ return (Attribute)obj;
+ }
+
public SchemaObject getParent() {
return parent;
}
return ((Element)obj).getName();
case SIMPLE_TYPE:
return ((SimpleType)obj).getName();
+ case ATTRIBUTE:
+ return ((Attribute)obj).getName();
}
throw new RuntimeException("Unknown object type " + type);
}
Code Review / simantics / interop.git / commitdiff