org.simantics.xml.sax/src/org/simantics/xml/sax/ExporterGenerator.java

   1 package org.simantics.xml.sax;
   2
   3 import java.io.File;
   4 import java.io.IOException;
   5 import java.io.PrintWriter;
   6 import java.io.StringWriter;
   7 import java.util.Collections;
   8 import java.util.List;
   9 import java.util.Map;
  10
  11 import javax.xml.namespace.QName;
  12
  13 import org.simantics.utils.datastructures.BijectionMap;
  14 import org.simantics.xml.sax.SchemaConversionBase.Inheritance;
  15 import org.simantics.xml.sax.SchemaConversionBase.InheritanceType;
  16 import org.simantics.xml.sax.SchemaConversionBase.RefType;
  17 import org.simantics.xml.sax.SchemaConversionBase.TypeEntry;
  18 import org.simantics.xml.sax.SchemaObject.ObjectType;
  19 import org.simantics.xml.sax.configuration.AttributeComposition;
  20 import org.simantics.xml.sax.configuration.IDProvider;
  21 import org.simantics.xml.sax.configuration.IDReference;
  22 import org.simantics.xml.sax.configuration.UnrecognizedChildElement;
  23 import org.w3._2001.xmlschema.Annotated;
  24 import org.w3._2001.xmlschema.Attribute;
  25 import org.w3._2001.xmlschema.AttributeGroup;
  26 import org.w3._2001.xmlschema.ComplexType;
  27 import org.w3._2001.xmlschema.Element;
  28 import org.w3._2001.xmlschema.LocalComplexType;
  29 import org.w3._2001.xmlschema.LocalSimpleType;
  30 import org.w3._2001.xmlschema.NamedAttributeGroup;
  31 import org.w3._2001.xmlschema.NamedGroup;
  32 import org.w3._2001.xmlschema.Restriction;
  33 import org.w3._2001.xmlschema.SimpleType;
  34
  35 public class ExporterGenerator extends JavaGenerator{
  36
  37         public ExporterGenerator(SchemaConverter converter, SchemaConversionBase base) {
  38                 super(converter, base);
  39         }
  40
  41         public void createParser() throws IOException {
  42
  43
  44                 String importerClassPostfix = "Exporter";
  45                 String parserClassPostfix = "Writer";
  46
  47                 importParserDir= new File(converter.getParserDir().getAbsolutePath()+"/"+elementPackageName);
  48                 if (!importParserDir.exists())
  49                         importParserDir.mkdirs();
  50
  51                 base.handle(this);
  52                 // Create Importer class
  53                 File importerFile = new File(converter.getParserDir().getAbsolutePath()+"/"+name+importerClassPostfix+".java");
  54                 PrintWriter mainWriter = createFile(importerFile);
  55                 mainWriter.println("package " + converter.getPluginName() +";");
  56                 mainWriter.println();
  57                 mainWriter.println("import java.io.File;");
  58                 mainWriter.println("import org.simantics.db.Resource;");
  59                 mainWriter.println("import org.simantics.db.Session;");
  60                 mainWriter.println("import org.simantics.db.exception.DatabaseException;");
  61                 mainWriter.println("import org.simantics.xml.sax.base.AbstractExporter;");
  62                 mainWriter.println();
  63                 mainWriter.println("public class " + name + importerClassPostfix+" extends AbstractExporter {");
  64                 mainWriter.println();
  65                 mainWriter.println("   public " + name + importerClassPostfix+"(Session session, File file, Resource root) throws DatabaseException {");
  66                 mainWriter.println("      super(session, file, root);");
  67                 mainWriter.println("      setXmlWriter(new "+name + parserClassPostfix+"(session).resolveDependencies(session));");
  68                 mainWriter.println("   }");
  69                 mainWriter.println();
  70                 mainWriter.println("}");
  71
  72                 mainWriter.println();
  73                 mainWriter.flush();
  74                 mainWriter.close();
  75
  76                 // Create Parser class
  77                 File parserFile = new File(converter.getParserDir().getAbsolutePath()+"/"+name+parserClassPostfix+".java");
  78                 mainWriter = createFile(parserFile);
  79                 mainWriter.println("package " + converter.getPluginName() +";");
  80                 mainWriter.println();
  81                 mainWriter.println("import org.simantics.xml.sax.base.XMLWriter;");
  82                 mainWriter.println("import org.simantics.db.ReadGraph;");
  83                 mainWriter.println("import org.simantics.db.Session;");
  84                 mainWriter.println("import org.simantics.db.exception.DatabaseException;");
  85                 mainWriter.println("import org.simantics.db.common.request.ReadRequest;");
  86                 mainWriter.println();
  87                 mainWriter.println("public class " + name + parserClassPostfix+" extends XMLWriter {");
  88                 mainWriter.println();
  89                 mainWriter.println("   public " + name + parserClassPostfix+"(Session session) throws DatabaseException {");
  90                 if (schema.getTargetNamespace() != null)
  91                 mainWriter.println("      setSchemaURI(\""+schema.getTargetNamespace()+"\");");
  92                 mainWriter.println("      setOntologyURI(\""+ontologyUri+"\");");
  93                 mainWriter.println("      session.syncRequest(new ReadRequest() {");
  94                 mainWriter.println("        @Override");
  95                 mainWriter.println("        public void run(ReadGraph graph) throws DatabaseException {");
  96                 mainWriter.println("          setGraph(graph);");
  97                 for (String s : ruleClassNames) {
  98                 mainWriter.println("          add(new "+s+"(graph));");
  99                 }
 100                 mainWriter.println("        }");
 101                 mainWriter.println("      });");
 102                 mainWriter.println("   }");
 103
 104                 mainWriter.println();
 105                 if (converter.getSubConverters().size() > 0) {
 106                 mainWriter.println("   public void addDependencies(org.simantics.db.Session session, java.util.Map<String,XMLWriter> map) throws DatabaseException {");
 107                 for (SchemaConverter sc : converter.getSubConverters()) {
 108                 String s = sc.className;
 109                 if (s.endsWith("Ontology"))
 110                         s = s.substring(0,s.length()-"Ontology".length());
 111                 s +="Writer";
 112                 mainWriter.println("      {");
 113                 mainWriter.println("         XMLWriter parser = new "+s+"(session);");
 114                 mainWriter.println("         if (!map.containsKey(parser.getSchemaURI())) {");
 115                 mainWriter.println("            map.put(parser.getSchemaURI(), parser);");
 116                 mainWriter.println("            parser.addDependencies(session,map);");
 117                 mainWriter.println("         } else {");
 118                 mainWriter.println("            parser = map.get(parser.getSchemaURI());");
 119                 mainWriter.println("         }");
 120                 mainWriter.println("         add(parser);");
 121                 mainWriter.println("      }");
 122                 }
 123                 mainWriter.println("   }");
 124
 125                 mainWriter.println("   public XMLWriter resolveDependencies(org.simantics.db.Session session) throws DatabaseException {");
 126                 mainWriter.println("      super.resolveDependencies(session);");
 127                 for (SchemaConverter sc : converter.getSubConverters()) {
 128                 String s = sc.schemaNs;
 129                 mainWriter.println("      if (!nsPrefixes.containsKey(\""+s+"\")) {");
 130                 mainWriter.println("         nsPrefixes.put(\""+s+"\", \"ns\"+nsPrefixes.size());");
 131                 mainWriter.println("      }");
 132                 }
 133                 mainWriter.println("      return this;");
 134                 mainWriter.println("   }");
 135                 }
 136                 mainWriter.println("}");
 137
 138                 mainWriter.println();
 139                 mainWriter.flush();
 140                 mainWriter.close();
 141         }
 142
 143         @Override
 144         protected String getPackagePostFix() {
 145                 return "_exp";
 146         }
 147
 148 //      @Override
 149 //      protected void handle(TopLevelAttribute topLevelAttribute) {
 150 //
 151 //      }
 152
 153         @Override
 154         public String getBaseClass(ObjectType type) {
 155                 return "org.simantics.xml.sax.base.XMLElementNamedChildWriterBase";
 156         }
 157
 158         @Override
 159         public void handleSimpleType(SchemaObject parent, SchemaObject simpleTypeObj) {
 160         }
 161
 162         @Override
 163         public void handle(SchemaObject parent, NamedGroup attribute) {
 164                 // TODO Auto-generated method stub
 165
 166         }
 167
 168         @Override
 169         public void handleComplexType(SchemaObject complexTypeObj) {
 170                 ComplexType topLevelComplexType = complexTypeObj.getComplexType();
 171
 172                 String name = getName(complexTypeObj);
 173
 174                 String className = name;//"_"+name;
 175
 176                 FileWriter fw = new FileWriter();
 177                 try {
 178                         fw.writer = createFile(new File(importParserDir.getAbsolutePath()+"/"+className+".java"));
 179                 } catch (IOException e) {
 180                         throw new RuntimeException(e);
 181                 }
 182                 writers.put(complexTypeObj, fw);
 183
 184 //              String baseClass = getBaseClass(ObjectType.COMPLEX_TYPE);
 185 //
 186 //              boolean inherited = false;
 187
 188 //              QName type = getComplexTypeBase(topLevelComplexType);
 189 //              if (type != null && !type.getNamespaceURI().equals("http://www.w3.org/2001/XMLSchema")) {
 190 //                      SchemaObject obj = complexTypeName.get(type.getLocalPart());
 191 ////                    if (obj == null)
 192 ////                            obj = simpleTypeName.get(type.getLocalPart());
 193 //                      if (obj != null) {
 194 //                              baseClass = getName(obj);
 195 //                              inherited = true;
 196 //                      }
 197 //              }
 198                 Inheritance inheritance = base.getInheritance(complexTypeObj);
 199
 200                 provider = base.getIDProvider(topLevelComplexType);
 201 //              List<IDReference> references = getIDReferences(topLevelComplexType);
 202 //              UnrecognizedChildElement unknownChildElement = getUnknown(topLevelComplexType);
 203
 204 //              List<String> intrerfaces = new ArrayList<String>();
 205 //              if (references.size() > 0)
 206 //                      intrerfaces.add("org.simantics.xml.sax.base.IDReferenceParser");
 207 //              if (unknownChildElement != null)
 208 //                      intrerfaces.add("org.simantics.xml.sax.base.UnrecognizedElementParser");
 209
 210                 createClassHeader(fw.writer);
 211                 writeClass(fw.writer,false, topLevelComplexType.getName(), className, inheritance.baseClass, Collections.<String>emptyList());
 212
 213 //              writeIDProvider(fw.writer);
 214
 215                 fw.writer.println("   @Override");
 216                 fw.writer.println("   public Resource getType(ReadGraph graph) throws DatabaseException {");
 217                 fw.writer.println("      "+getOntologyImport());
 218                 fw.writer.println("      return "+ontShort+name+";");
 219                 fw.writer.println("   }");
 220                 fw.writer.println();
 221
 222 //              fw.writer.println("   @Override");
 223 //              fw.writer.println("   public Resource create(WriteGraph graph, ParserElement element) throws DatabaseException{");
 224 //              fw.writer.println("      Layer0 L0 = Layer0.getInstance(graph);");
 225 //              fw.writer.println("      "+getOntologyImport());
 226 //              if (!isList) {
 227 //              fw.writer.println("      Resource res = graph.newResource();");
 228 //              fw.writer.println("      graph.claim(res, L0.InstanceOf, "+ontShort+name+");");
 229 //              } else {
 230 //              fw.writer.println("      Resource res = ListUtils.create(graph, "+ontShort+name+", Collections.EMPTY_LIST);");
 231 //              }
 232 //              fw.writer.println("      return res;");
 233 //              fw.writer.println("   }");
 234 //              fw.writer.println();
 235
 236 //              fw.writer.println("   @Override");
 237 //              fw.writer.println("   public boolean connectParent(WriteGraph graph, ParserElement parent, ParserElement element) throws DatabaseException{");
 238 //              fw.writer.println("      "+getOntologyImport());
 239 //              fw.writer.println("      graph.claim(parent.getData(), "+this.ontShort+getName(complexTypeObj,"has")+", element.getData());");
 240 //              fw.writer.println("      return true;");
 241 //              fw.writer.println("   }");
 242 //              fw.writer.println();
 243
 244                 StringWriter stringWriter = new StringWriter();
 245                 fw.delayedWriter = new PrintWriter(stringWriter);
 246                 StringWriter stringWriter2 = new StringWriter();
 247                 fw.delayedWriter2 = new PrintWriter(stringWriter2);
 248
 249                 fw.writer.println("   public " + className + "(ReadGraph graph) {");
 250                 fw.writer.println("      super(graph);");
 251                 fw.writer.println("      "+getOntologyImport());
 252
 253                 base.handleComplexTypeExtension(complexTypeObj);
 254
 255                 fw.writer.println("   }");
 256
 257                 fw.writer.println("   @Override");
 258                 fw.writer.println("   public void children(ReadGraph graph, WriterElement instance, java.util.Set<org.simantics.db.Resource> result) throws XMLStreamException, DatabaseException {");
 259                 fw.writer.println("      "+getOntologyImport());
 260
 261                 if (stringWriter.getBuffer().length() > 0) {
 262                         fw.writer.write(stringWriter.toString());
 263                 }
 264                 if (inheritance.type == InheritanceType.ComplexType)
 265                 fw.writer.println("      super.children(graph,instance,result);");
 266                 fw.writer.println("   }");
 267                 fw.writer.println();
 268
 269                 if (stringWriter2.getBuffer().length() > 0) {
 270                         fw.writer.write(stringWriter2.toString());
 271                 }
 272
 273                 stringWriter = null;
 274                 fw.delayedWriter.close();
 275                 fw.delayedWriter=null;
 276                 stringWriter2 = null;
 277                 fw.delayedWriter2.close();
 278                 fw.delayedWriter2 = null;
 279
 280                 fw.writer.println("   @Override");
 281                 fw.writer.println("   public void attributes(ReadGraph graph, WriterElement instance, Collection<Statement> attributes, XMLStreamWriter writer) throws XMLStreamException, DatabaseException{");
 282                 if (inheritance.type == InheritanceType.ComplexType) {
 283                 fw.writer.println("             super.attributes(graph,instance,attributes,writer);");
 284                 }
 285                 fw.writer.println("        "+getOntologyImport());
 286                 fw.writer.println("        for (Statement attribute : attributes) {");
 287                 base.handleComplexTypeAttributes(complexTypeObj);
 288                 base.handleExtensionAttributes(complexTypeObj);
 289                 fw.writer.println("        }");
 290                 fw.writer.println("   }");
 291
 292                 if (inheritance.type == InheritanceType.AtomicType) {
 293                 fw.writer.println();
 294                 fw.writer.println("   @Override");
 295                 fw.writer.println("   public void characters(ReadGraph graph, WriterElement instance, XMLStreamWriter writer) throws XMLStreamException, DatabaseException {");
 296                 fw.writer.println("            writer.writeCharacters("+inheritance.atomicType.getToString("graph.getValue(instance.getResource(),"+inheritance.atomicType.binding+")")+");");
 297                 fw.writer.println("   }");
 298                 }
 299
 300 //              writeIDReferences(fw.writer,name, references);
 301 //              writeUnknownChild(fw.writer,name,unknownChildElement);
 302
 303                 fw.writer.println("}");
 304                 fw.writer.println();
 305                 fw.writer.flush();
 306                 fw.writer.close();
 307                 fw.writer = null;
 308                 writers.remove(complexTypeObj);
 309                 provider = null;
 310         }
 311
 312         @Override
 313         protected void createReferenceIndicator(SchemaObject parent, RefType referenceType, String refName, String objectName,
 314                         String primaryClassName, String secondaryClassName, boolean useElementList, boolean useOriginalList) {
 315                 FileWriter fw = getWriter(parent);
 316                 if (referenceType == RefType.Type) {
 317                 // create internal class for handling the element and child attachment
 318                 secondaryClassName = getName(parent) +"_" +objectName;
 319                 if (objectName.equals(refName))
 320                 fw.writer.println("      addRelationWriter("+ontShort+ getName(parent)+"_has"+refName +", "+secondaryClassName+".class);");
 321                 else // FIXME : type name may not be correct
 322                 fw.writer.println("      addRelationTypeWriter("+ontShort+ getName(parent)+"_has"+refName +", " +ontShort+primaryClassName +", "+secondaryClassName+".class);");
 323                 fw.delayedWriter2.println("   public static class " + secondaryClassName +" extends " + primaryClassName +"{");
 324                 fw.delayedWriter2.println("      public "+ secondaryClassName +"(ReadGraph graph){");
 325                 fw.delayedWriter2.println("         super(graph);");
 326                 fw.delayedWriter2.println("      }");
 327                 fw.delayedWriter2.println("      ");
 328                 fw.delayedWriter2.println("      @Override");
 329                 fw.delayedWriter2.println("      public java.lang.String getElementId() {");
 330                 fw.delayedWriter2.println("         return \"" + refName +"\";");
 331                 fw.delayedWriter2.println("      }");
 332                 fw.delayedWriter2.println("   }");
 333                 } else { //referenceType == RefType.Reference
 334                 fw.writer.println("        addWriter("+primaryClassName+".class);");
 335                 if (!primaryClassName.equals(secondaryClassName))
 336                 fw.writer.println("        addWriter("+secondaryClassName+".class);");
 337                 }
 338 //                      fw.delayedWriter.println("         if (child.getElementParser() instanceof "+refClassName+"){");
 339 //                      fw.delayedWriter.println("            graph.claim(element.getData(), "+ontShort+getName(parent)+"_has"+ref + ", child.getData());");
 340                 if (useElementList) {
 341
 342                 // element type specific list
 343                 fw.delayedWriter.println("      {");
 344                 fw.delayedWriter.println("         org.simantics.db.Resource list = graph.getPossibleObject(instance.getResource(),"+ontShort+getName(parent)+"_has"+refName + "_List);");
 345                 fw.delayedWriter.println("         if (list != null) {");
 346                 fw.delayedWriter.println("            java.util.List<org.simantics.db.Resource> l = org.simantics.db.common.utils.ListUtils.toList(graph, list);");
 347                 fw.delayedWriter.println("            result.addAll(l);");
 348                 fw.delayedWriter.println("         } else {");
 349                 fw.delayedWriter.println("            result.addAll(graph.getObjects(instance.getResource(), "+ontShort+getName(parent)+"_has"+refName + "));");
 350                 fw.delayedWriter.println("         }");
 351                 fw.delayedWriter.println("      }");
 352                 } else {
 353                 fw.delayedWriter.println("      result.addAll(graph.getObjects(instance.getResource(), "+ontShort+getName(parent)+"_has"+refName + "));");
 354                 }
 355 //                      if (useOriginalList(parent, indicator,element, reference, ref, refType)) {
 356 //                      // generic list
 357 //                      fw.delayedWriter.println("            {");
 358 //                      fw.delayedWriter.println("               XMLResource XML = XMLResource.getInstance(graph);");
 359 //                      fw.delayedWriter.println("               Resource list = graph.getPossibleObject(element.getData(), XML.hasOriginalElementList);");
 360 //                      fw.delayedWriter.println("               if (list == null) {");
 361 //                      fw.delayedWriter.println("                  list = org.simantics.db.common.utils.ListUtils.create(graph, java.util.Collections.singletonList(child.getData()));");
 362 //                      fw.delayedWriter.println("                  graph.claim(element.getData(), XML.hasOriginalElementList,list);");
 363 //                      fw.delayedWriter.println("               } else {");
 364 //                      fw.delayedWriter.println("                  org.simantics.db.common.utils.ListUtils.insertBack(graph, list, java.util.Collections.singletonList(child.getData()));");
 365 //                      fw.delayedWriter.println("               }");
 366 //                      fw.delayedWriter.println("            }");
 367 //                      }
 368
 369 //                      fw.delayedWriter.println("            return true;");
 370 //                      fw.delayedWriter.println("         }");
 371
 372         }
 373
 374         @Override
 375         protected void createPrimitiveIndicator(SchemaObject parent, String refName, TypeEntry typeEntry, QName typeName) {
 376                 FileWriter fw = getWriter(parent);
 377                 String ontologyClassName = converter.getOntologyClassName(typeName.getNamespaceURI());
 378                 String typeURI = ontologyClassName != null ? ontologyClassName + ".URIs." + getName(base.getSimpleType(typeName)) : "null";
 379
 380                 fw.writer.println("      addRelationWriter("+ ontShort +getName(parent) + "_has"+refName+", "+getName(parent) +"_" +refName+".class);");
 381
 382                 fw.delayedWriter2.println("   public static class " + getName(parent) +"_" +refName+" extends org.simantics.xml.sax.base.ValueElementWriter {");
 383                 fw.delayedWriter2.println("      public "+ getName(parent) +"_" +refName +"(){");
 384                 fw.delayedWriter2.println("         super(\""+refName+"\", " + typeURI + ", " + typeEntry.binding+");");
 385                 fw.delayedWriter2.println("      }\n");
 386                 fw.delayedWriter2.println("      @Override");
 387                 fw.delayedWriter2.println("      public java.lang.String decode(java.lang.Object value) {");
 388                 fw.delayedWriter2.println("         return " + typeEntry.stringPrefix + "(" + typeEntry.javaType + ")value" + typeEntry.stringPostfix + ";");
 389                 fw.delayedWriter2.println("      }");
 390                 fw.delayedWriter2.println("   }");
 391         }
 392
 393         @Override
 394         protected void createElementIndicator(SchemaObject parent, boolean useElementList, String refName, String className,
 395                         boolean useOriginalList) {
 396                 FileWriter fw = getWriter(parent);
 397                 //if (!reference)
 398                 fw.writer.println("        addTypeWriter("+ ontShort+className +", "+className+".class);");
 399 //              else
 400 //              fw.writer.println("        addWriter("+className+".class);");
 401
 402 //              fw.delayedWriter.println("         if (child.getElementParser() instanceof "+className+"){");
 403 //              fw.delayedWriter.println("            graph.claim(element.getData(), "+ontShort+getName(parent)+"_has"+ref + ", child.getData());");
 404                 if (useElementList) {
 405
 406                 // element type specific list
 407                 fw.delayedWriter.println("            {");
 408                 fw.delayedWriter.println("               org.simantics.db.Resource list = graph.getPossibleObject(instance.getResource(),"+ontShort+getName(parent)+"_has"+refName + "_List);");
 409                 fw.delayedWriter.println("               if (list != null) {");
 410                 fw.delayedWriter.println("                  java.util.List<org.simantics.db.Resource> l = org.simantics.db.common.utils.ListUtils.toList(graph, list);");
 411                 fw.delayedWriter.println("                  result.addAll(l);");
 412                 fw.delayedWriter.println("               } else {");
 413                 fw.delayedWriter.println("                  result.addAll(graph.getObjects(instance.getResource(), "+ontShort+getName(parent)+"_has"+refName + "));");
 414                 fw.delayedWriter.println("               }");
 415                 fw.delayedWriter.println("            }");
 416                 } else {
 417                 fw.delayedWriter.println("         result.addAll(graph.getObjects(instance.getResource(), "+ontShort+getName(parent)+"_has"+refName + "));");
 418                 }
 419 //              if (useOriginalList(parent, indicator,element, reference, ref, new QName(obj.getName()))) {
 420 //              // generic list
 421 //              fw.delayedWriter.println("            {");
 422 //              fw.delayedWriter.println("               XMLResource XML = XMLResource.getInstance(graph);");
 423 //              fw.delayedWriter.println("               Resource list = graph.getPossibleObject(element.getData(), XML.hasOriginalElementList);");
 424 //              fw.delayedWriter.println("               if (list == null) {");
 425 //              fw.delayedWriter.println("                  list = org.simantics.db.common.utils.ListUtils.create(graph, java.util.Collections.singletonList(child.getData()));");
 426 //              fw.delayedWriter.println("                  graph.claim(element.getData(), XML.hasOriginalElementList,list);");
 427 //              fw.delayedWriter.println("               } else {");
 428 //              fw.delayedWriter.println("                  org.simantics.db.common.utils.ListUtils.insertBack(graph, list, java.util.Collections.singletonList(child.getData()));");
 429 //              fw.delayedWriter.println("               }");
 430 //              fw.delayedWriter.println("            }");
 431 //              }
 432 //
 433 //              fw.delayedWriter.println("            return true;");
 434 //              fw.delayedWriter.println("         }");
 435
 436         }
 437
 438         @Override
 439         public void handleIndicator(SchemaObject parent, SchemaElement indicator, SchemaElement any) {
 440                 // generates overriding method that allows writing any element
 441                 FileWriter fw = getWriter(parent);
 442                 fw.delayedWriter2.println("   @Override");
 443                 fw.delayedWriter2.println("   public Class<? extends org.simantics.xml.sax.base.XMLElementWriter> getWriter(ReadGraph graph, java.util.Map<Resource, org.simantics.xml.sax.base.XMLElementWriter> writers, WriterElement child) throws DatabaseException{");
 444                 fw.delayedWriter2.println("      Class<? extends org.simantics.xml.sax.base.XMLElementWriter> writerClass = super.getWriter(graph, writers, child);");
 445                 fw.delayedWriter2.println("      if (writerClass != null) return writerClass;");
 446                 fw.delayedWriter2.println("      Resource type = graph.getSingleType(child.instance);");
 447                 fw.delayedWriter2.println("      org.simantics.xml.sax.base.XMLElementWriter writer = writers.get(type);");
 448                 fw.delayedWriter2.println("      if (writer != null) return writer.getClass();");
 449                 fw.delayedWriter2.println("      return null;");
 450                 fw.delayedWriter2.println("   }");
 451         }
 452
 453         @Override
 454         public void handle(SchemaObject parent, Attribute attribute) {
 455                 if (parent == null)
 456                         return;
 457                 String name = attribute.getName();
 458                 QName primitiveType = attribute.getType();
 459                 SimpleType simpleType = attribute.getSimpleType();
 460                 QName ref = attribute.getRef();
 461
 462                 String relationName;
 463                 String attrName;
 464                 String ns = null;
 465                 if (name != null) {
 466                         attrName = name;
 467                         relationName = ontShort+"has"+base.getName(attribute);
 468                         if (parent != null)
 469                                 relationName = ontShort+getName(parent)+"_has"+base.getName(attribute);
 470                 }
 471                 else if (ref != null && parent != null) {
 472                         attrName = ref.getLocalPart();
 473                         relationName = ontShort+getName(parent)+"_has"+base.getName(ref);
 474
 475                         Attribute referred = base.getRefAttribute(ref);
 476                         if (referred != null) {
 477                                 primitiveType = referred.getType();
 478                                 simpleType = referred.getSimpleType();
 479                                 if (ref.getNamespaceURI() != null && !ref.getNamespaceURI().equals(this.converter.schemaNs))
 480                                         ns = ref.getNamespaceURI();
 481                         }
 482
 483                 } else {
 484                         throw new RuntimeException();
 485                 }
 486                 boolean isReference = false;
 487                 if (provider!= null && provider.getAttribute().getName().equals(attrName))
 488                         isReference = true;
 489
 490                 FileWriter fw = getWriter(parent);
 491                 if (primitiveType != null) {
 492
 493                         //String binding = getBindingFromPrimitiveType(primitiveType);
 494                         TypeEntry binding = base.getTypeEntry(primitiveType);
 495
 496                         if (binding != null) {
 497                                 if (ns != null)
 498                                         writeAttribute(fw, ns, attrName, relationName, binding, isReference);
 499                                 else
 500                                         writeAttribute(fw, attrName, relationName, binding, isReference);
 501                                 return;
 502                     } else {
 503                         if (simpleType == null) {
 504                                 SchemaObject simpleTypeObj = base.getSimpleType(primitiveType);
 505                                 if (simpleTypeObj != null)
 506                                         simpleType = simpleTypeObj.getSimpleType();
 507                         }
 508                     }
 509                 }
 510
 511                 if (simpleType != null) {
 512                         org.w3._2001.xmlschema.List list = simpleType.getList();
 513                         if (list != null) {
 514                                 TypeEntry binding = base.getTypeEntry(new QName(SchemaConversionBase.SCHEMA_NS, "string"));
 515                                 writeAttribute(fw, attrName, relationName, binding, isReference);
 516                         } else {
 517                                 Restriction restriction = simpleType.getRestriction();
 518                                 if (restriction == null)
 519                                         throw new RuntimeException("Cannot resolve type for Attribute " + attrName + " -> " + primitiveType.getLocalPart()+ ", SimpleType restriction is unset");
 520                                 QName base = restriction.getBase();
 521
 522
 523                                 //String binding = getBindingFromPrimitiveType(base);
 524                                 TypeEntry binding = this.base.getTypeEntry(base);
 525                                 if (base.getNamespaceURI() != null)
 526                                         writeAttribute(fw, base.getNamespaceURI(), attrName, relationName, binding, isReference);
 527                                 else
 528                                         writeAttribute(fw, attrName, relationName, binding, isReference);
 529                         }
 530                 } else {
 531                         // TODO : using default String attribute should be configured with rules.
 532                         //throw new RuntimeException("Cannot resolve type for Attribute " + attrName + " -> " + primitiveType.getLocalPart());
 533                         fw.writer.println("    //FIXME: Cannot resolve type for Attribute " + attrName + " Using default type String");
 534                         //writeAttribute(fw, attrName, relationName, "STRING", isReference);
 535                         writeAttribute(fw, attrName, relationName, base.getTypeEntry("string"), isReference);
 536                 }
 537         }
 538
 539         private void writeAttribute(FileWriter fw, String attrName, String relationName, TypeEntry binding, boolean isReference) {
 540                 fw.writer.println("      {");
 541                 fw.writer.println("         if (attribute.getPredicate().equals("+relationName+")) {");
 542                 fw.writer.println("            writer.writeAttribute(\""+attrName+"\", " + binding.getToString("graph.getValue(attribute.getObject(),"+binding.binding+")")+");");
 543         //      fw.writer.println("            graph.claimLiteral(element.getData(),"+relationName+","+getValueGetterMethod(binding,"a")+", "+binding.binding+");");
 544         //      if (isReference)
 545         //      fw.writer.println("            idProviderValue = a.getValue();");
 546                 fw.writer.println("         }");
 547                 fw.writer.println("      }");
 548         }
 549
 550         private void writeAttribute(FileWriter fw, String ns,  String attrName, String relationName, TypeEntry binding, boolean isReference) {
 551                 fw.writer.println("      {");
 552                 fw.writer.println("         if (attribute.getPredicate().equals("+relationName+")) {");
 553                 fw.writer.println("            writer.writeAttribute(\""+ns+"\",\""+attrName+"\", " + binding.getToString("graph.getValue(attribute.getObject(),"+binding.binding+")")+");");
 554         //      fw.writer.println("            graph.claimLiteral(element.getData(),"+relationName+","+getValueGetterMethod(binding,"a")+", "+binding.binding+");");
 555         //      if (isReference)
 556         //      fw.writer.println("            idProviderValue = a.getValue();");
 557                 fw.writer.println("         }");
 558                 fw.writer.println("      }");
 559         }
 560
 561         @Override
 562         public void handleAttributes(SchemaObject simpleTypeObj) {
 563                 SchemaObject parent = simpleTypeObj.getParent();
 564                 FileWriter fw = getWriter(parent);
 565
 566                 SimpleType simpleType = simpleTypeObj.getSimpleType();
 567                 Restriction restriction = simpleType.getRestriction();
 568                 if (restriction == null)
 569                         throw new RuntimeException("Cannot resolve type for Element " + getName(parent));
 570                 QName base = restriction.getBase();
 571
 572
 573                 //String binding = getBindingFromPrimitiveType(base);
 574                 TypeEntry binding = this.base.getTypeEntry(base);
 575
 576                 fw.writer.println("   @Override");
 577                 fw.writer.println("   public void characters(ReadGraph graph, WriterElement instance, XMLStreamWriter writer) throws XMLStreamException, DatabaseException {");
 578                 fw.writer.println("            writer.writeCharacters("+ binding.getToString("graph.getValue(attribute.getObject(),"+binding.binding+")")+");");
 579 //              fw.writer.println("      graph.claimValue(element.getData(),"+getValueGetter(binding)+", "+binding.binding +");");
 580                 fw.writer.println("   }");
 581         }
 582
 583         @Override
 584         public void handle(SchemaObject parent, AttributeGroup attribute) {
 585                 if (parent != null) {
 586                         FileWriter fw = getWriter(parent);
 587                         NamedAttributeGroup group = this.base.getAttributeGroup(attribute.getRef());
 588                         fw.writer.println(commentTag+"    AttributeGroup " + group.getName());
 589                         SchemaObject obj = new SchemaObject(base,parent,attribute);
 590                         for (Annotated annotated : group.getAttributeOrAttributeGroup()) {
 591                                 if (annotated instanceof Attribute) {
 592                                         //handle("AttributeGroups_"+group.getName(),(Attribute)annotated);
 593                                         handle(obj,(Attribute)annotated);
 594                                 } else if (annotated instanceof AttributeGroup) {
 595                                         //handle("AttributeGroups_"+group.getName(),(AttributeGroup)annotated);
 596                                         handle(obj,(AttributeGroup)annotated);
 597                                 }
 598                         }
 599                         fw.writer.println(commentTag+"    End of AttributeGroup " + group.getName());
 600                 }
 601
 602         }
 603
 604         @Override
 605         public void handleAttributeComposition(SchemaObject parent, AttributeComposition composition, BijectionMap<org.simantics.xml.sax.configuration.Attribute, Annotated> attributes) {
 606                 FileWriter fw = getWriter(parent);
 607                 QName type = new QName(SchemaConversionBase.CONVERSION_NS, composition.getType());
 608                 TypeEntry typeEntry = this.base.getTypeEntry(type);
 609                 String arrayBinding = typeEntry.binding;//getBindingFromPrimitiveType(type);
 610                 String javaType = typeEntry.javaType;//getJavaTypeFromPrimitiveType(type);
 611                 String name = composition.getName();
 612
 613                 String relationName;
 614                 if (name != null) {
 615                         relationName = ontShort+"has"+name;
 616                         if (parent != null)
 617                                 relationName = ontShort+getName(parent)+"_has"+name;
 618                 } else {
 619                         throw new RuntimeException();
 620                 }
 621                 fw.writer.println("      if (attribute.getPredicate().equals("+relationName+")) {");
 622                 fw.writer.println("            "+javaType+" value = ("+javaType+")graph.getValue(attribute.getObject(),"+arrayBinding+");");
 623                 //fw.writer.println("            writer.writeAttribute("+attrName+", graph.getValue(attribute.getObject(),"+binding.binding+").toString());");
 624
 625                 int i = 0;
 626                 for (org.simantics.xml.sax.configuration.Attribute a : composition.getAttribute())
 627                 fw.writer.println("            writer.writeAttribute(\""+a.getName()+"\","+typeEntry.getElementToString("value["+(i++)+"]")+");");
 628                 //fw.writer.println("            writer.writeAttribute(\""+a.getName()+"\",value["+(i++)+"].toString());");
 629 //              fw.writer.println("         Attribute a"+(i++)+" = element.getAttribute(\"" +a.getName()+"\");");
 630 //              fw.writer.print  ("         "+javaType + " value = new "+javaType+"{");
 631                 i = 0;
 632                 // FIXME : handle optional attributes properly.
 633 //              for (org.simantics.xml.sax.configuration.Attribute a : composition.getAttribute()) {
 634 //                      Attribute attribute = ((Attribute)attributes.getRight(a));
 635 //                      //QName atype = getBaseType(attribute);
 636 //                      QName atype = getPrimitiveType(attribute);
 637 //                      String defaultValue = attribute.getDefault();
 638 //                      if (defaultValue == null)
 639 //                          defaultValue = getDefaultValue(atype);
 640 //
 641 //                      //String binding = getBindingFromPrimitiveType(atype);
 642 //                      TypeEntry binding = getTypeEntry(atype);
 643 //                      if (i > 0)
 644 //                              fw.writer.print(",");
 645 //                      if (defaultValue != null)
 646 //                              fw.writer.print("a"+(i)+"!= null ? "+ getValueGetterMethod(binding,"a"+(i++)) + " : " +defaultValue);
 647 //                      else
 648 //                              fw.writer.print(getValueGetterMethod(binding,"a"+(i++)));
 649 //              }
 650 //              fw.writer.println("};");
 651 //              fw.writer.println("         graph.claimLiteral(element.getData(),"+relationName+", value, "+arrayBinding+");");
 652                 fw.writer.println("      }");
 653
 654         }
 655
 656         protected String getDefaultValue(QName atype) {
 657                 Map<String,TypeEntry> types = this.base.typeMap.get(atype.getNamespaceURI());
 658                 if (types == null)
 659                         return null;
 660                 TypeEntry entry =  types.get(atype.getLocalPart());
 661                 if (entry == null)
 662                         return null;
 663                 return entry.defaultValue;
 664         }
 665
 666         IDProvider provider;
 667         @Override
 668         public void handleElement(SchemaObject elementObj)  {
 669                 Element element = elementObj.getElement();
 670
 671                 String name = getName(elementObj);//topLevelElement.getName();
 672                 String className = name;
 673
 674                 FileWriter fw = new FileWriter();
 675                 try {
 676                         fw.writer = createFile(new File(importParserDir.getAbsolutePath()+"/"+className+".java"));
 677                 } catch (IOException e) {
 678                         throw new RuntimeException(e);
 679                 }
 680                 writers.put(elementObj, fw);
 681                 boolean isList = false;
 682
 683                 Inheritance inheritance = this.base.getInheritance(elementObj);
 684
 685                 provider = this.base.getIDProvider(element);
 686                 List<IDReference> references = this.base.getIDReferences(element);
 687                 UnrecognizedChildElement unknownChildElement = this.base.getUnknown(element);
 688
 689 //              List<String> intrerfaces = new ArrayList<String>();
 690 //              if (references.size() > 0)
 691 //                      intrerfaces.add("org.simantics.xml.sax.base.IDReferenceParser");
 692 //              if (unknownChildElement != null)
 693 //                      intrerfaces.add("org.simantics.xml.sax.base.UnrecognizedElementParser");
 694
 695                 createClassHeader(fw.writer);
 696                 writeClass(fw.writer,false, element.getName(), className, inheritance.baseClass, Collections.EMPTY_LIST);
 697 //              writeIDProvider(fw.writer);
 698                 fw.writer.println("   @Override");
 699                 fw.writer.println("   public Resource getType(ReadGraph graph) throws DatabaseException {");
 700                 fw.writer.println("      "+getOntologyImport());
 701                 fw.writer.println("      return "+ontShort+name+";");
 702 //              if (!isList) {
 703 //              fw.writer.println("      Resource res = graph.newResource();");
 704 //              fw.writer.println("      graph.claim(res, L0.InstanceOf, "+ontShort+name+");");
 705 //              } else {
 706 //              fw.writer.println("      Resource res = ListUtils.create(graph, "+ontShort+name+", Collections.EMPTY_LIST);");
 707 //              }
 708 //              fw.writer.println("      return res;");
 709                 fw.writer.println("   }");
 710                 fw.writer.println();
 711
 712 //              fw.writer.println("   @Override");
 713 //              fw.writer.println("   public boolean connectParent(WriteGraph graph, ParserElement parent, ParserElement element) throws DatabaseException{");
 714 //              fw.writer.println("      "+getOntologyImport());
 715 //              fw.writer.println("      graph.claim(parent.getData(), "+this.ontShort+getName(elementObj,"has")+", element.getData());");
 716 //              fw.writer.println("      return true;");
 717 //              fw.writer.println("   }");
 718 //              fw.writer.println();
 719                 LocalComplexType complexType = element.getComplexType();
 720                 LocalSimpleType simpleType = element.getSimpleType();
 721
 722                 fw.writer.println("   @Override");
 723                 fw.writer.println("   public void attributes(ReadGraph graph, WriterElement instance, Collection<Statement> attributes, XMLStreamWriter writer) throws XMLStreamException, DatabaseException{");
 724                 if (inheritance.type == InheritanceType.ComplexType) {
 725                 fw.writer.println("        super.attributes(graph,instance,attributes,writer);");
 726                 }
 727                 fw.writer.println("        "+getOntologyImport());
 728                 fw.writer.println("        for (Statement attribute : attributes) {");
 729                 if (complexType != null) {
 730                         SchemaObject obj = this.base.getComplexType(complexType);
 731                         this.base.handleElementComplexTypeAttributes(obj);
 732                 }
 733                 fw.writer.println("        }");
 734                 fw.writer.println("   }");
 735
 736
 737 //              fw.writer.println("   @Override");
 738 //              fw.writer.println("   public void configure(WriteGraph graph, Deque<ParserElement> parents, ParserElement element) throws DatabaseException {");
 739 //              if (inhertiance.type == InheritanceType.ComplexType) {
 740 //              fw.writer.println("             super.configure(graph,parents,element);");
 741 //              }
 742 //              fw.writer.println("        "+getOntologyImport());
 743 //
 744 //              LocalComplexType complexType = element.getComplexType();
 745 //              LocalSimpleType simpleType = element.getSimpleType();
 746 //
 747 //              if (complexType != null) {
 748 //                      SchemaObject obj = complexTypes.get(complexType);
 749 //                      handleElementComplexTypeAttributes(obj);
 750 //              }
 751 //              fw.writer.println("   }");
 752
 753                 if (inheritance.type == InheritanceType.AtomicType) {
 754                 fw.writer.println();
 755 //              fw.writer.println("   @Override");
 756 //              fw.writer.println("   public void configure(WriteGraph graph, ParserElement element, java.lang.String string) throws DatabaseException {");
 757 //              fw.writer.println("      graph.claimValue(element.getData(), "+getValueGetter(inhertiance.atomicType,"string")+", "+inhertiance.atomicType.binding+");");
 758 //              fw.writer.println("   }");
 759                 fw.writer.println("   @Override");
 760                 fw.writer.println("   public void characters(ReadGraph graph, WriterElement instance, XMLStreamWriter writer) throws XMLStreamException, DatabaseException {");
 761                 fw.writer.println("            writer.writeCharacters("+inheritance.atomicType.getToString("graph.getValue(instance.getResource(),"+inheritance.atomicType.binding+")")+");");
 762 //              fw.writer.println("      graph.claimValue(element.getData(),"+getValueGetter(binding)+", "+binding.binding +");");
 763                 fw.writer.println("   }");
 764                 }
 765 //              if (simpleType != null) {
 766 //                      SchemaObject obj = simpleTypes.get(simpleType);
 767 //                      handleElementSimpleTypeAttributes(obj);
 768 //              }
 769
 770
 771                 StringWriter stringWriter = new StringWriter();
 772                 fw.delayedWriter = new PrintWriter(stringWriter);
 773                 StringWriter stringWriter2 = new StringWriter();
 774                 fw.delayedWriter2 = new PrintWriter(stringWriter2);
 775
 776                 fw.writer.println("   public " + className + "(ReadGraph graph) {");
 777                 fw.writer.println("      super(graph);");
 778                 fw.writer.println("      "+getOntologyImport());
 779                 if (complexType != null) {
 780                         SchemaObject obj = this.base.getComplexType(complexType);
 781                         this.base.handleComplexTypeExtension(obj);
 782                 } else if (simpleType != null) {
 783
 784                 }
 785
 786                 fw.writer.println("   }");
 787
 788                 fw.writer.println("   @Override");
 789                 fw.writer.println("   public void children(ReadGraph graph, WriterElement instance, java.util.Set<org.simantics.db.Resource> result) throws XMLStreamException, DatabaseException {");
 790                 fw.writer.println("      "+getOntologyImport());
 791
 792                 if (stringWriter.getBuffer().length() > 0) {
 793                         fw.writer.write(stringWriter.toString());
 794                 }
 795
 796                 if (inheritance.type == InheritanceType.ComplexType) {
 797                 fw.writer.println("      super.children(graph,instance,result);");
 798                 }
 799
 800                 fw.writer.println("   }");
 801                 fw.writer.println();
 802
 803                 if (stringWriter2.getBuffer().length() > 0) {
 804                         fw.writer.write(stringWriter2.toString());
 805                 }
 806
 807                 stringWriter = null;
 808                 fw.delayedWriter.close();
 809                 fw.delayedWriter = null;
 810                 stringWriter2 = null;
 811                 fw.delayedWriter2.close();
 812                 fw.delayedWriter2 = null;
 813
 814 //              writeIDReferences(fw.writer,name, references);
 815 //              writeUnknownChild(fw.writer,name,unknownChildElement);
 816
 817                 fw.writer.println("}");
 818                 fw.writer.println();
 819                 fw.writer.flush();
 820                 fw.writer.close();
 821                 fw.writer = null;
 822                 writers.remove(elementObj);
 823                 provider = null;
 824
 825                 ruleClassNames.add(converter.getPluginName()+"."+elementPackageName+"."+name);
 826         }
 827
 828
 829 //      private void writeIDProvider(PrintWriter writer) {
 830 //              if (provider != null) {
 831 //              writer.println("   java.lang.String idProviderValue = null;");
 832 //              writer.println();
 833 //              writer.println("   @Override");
 834 //              writer.println("   public java.lang.String getID() {");
 835 //              writer.println("        java.lang.String s = idProviderValue;");
 836 //              writer.println("        idProviderValue = null;");
 837 //              writer.println("        return s;");
 838 //              writer.println("   }");
 839 //              writer.println();
 840 //              if (provider.getPriority() != null) {
 841 //              writer.println("   @Override");
 842 //              writer.println("   public int idPriority() {");
 843 //              writer.println("        return " + provider.getPriority().intValue()+";");
 844 //              writer.println("   }");
 845 //              }
 846 //              }
 847 //      }
 848 //
 849 //      private void writeIDReferences(PrintWriter writer,String name, List<IDReference> references) {
 850 //              if (references.size() > 0) {
 851 //              writer.println("   @Override");
 852 //              writer.println("   public boolean connectReferences(WriteGraph graph, ParserElement element, java.util.Map<java.lang.String, ParserElement> map) throws DatabaseException {");
 853 //              writer.println("      "+getOntologyImport());
 854 //              writer.println("      boolean result = true;");
 855 //              for (IDReference ref : references) {
 856 //              writer.println("      {");
 857 //              writer.println("         Attribute a = element.getAttribute(\"" + ref.getIDSource().getName() +"\");");
 858 //              writer.println("         if (a != null) {");
 859 //              writer.println("            ParserElement refEle = map.get(a.value);");
 860 //              writer.println("            if (refEle != null) {");
 861 //              writer.println("               Resource ref = refEle.getData();");
 862 //              writer.println("               graph.claim(element.getData(), "+ontShort+name+"_"+ref.getReference().getName()+", ref);");
 863 //              writer.println("            } else {");
 864 //              writer.println("               result = false;");
 865 //              writer.println("            }");
 866 //              writer.println("         }");
 867 //              writer.println("      }");
 868 //              }
 869 //              writer.println("      return result;");
 870 //              writer.println("   }");
 871 //              writer.println();
 872 //              }
 873 //      }
 874
 875 //      private void writeUnknownChild(PrintWriter writer,String name, UnrecognizedChildElement unknownChildElement) {
 876 //              if (unknownChildElement == null)
 877 //                      return;
 878 //
 879 //              writer.println("   @Override");
 880 //              writer.println("   public void configureChild(WriteGraph graph, Deque<ParserElement> parents, ParserElement element, ParserElement child) throws DatabaseException {");
 881 //              writer.println("    " + unknownChildElement.getJavaMethod());
 882 //              writer.println("   }");
 883 //              writer.println();
 884 //
 885 //      }
 886
 887         protected void createClassHeader(PrintWriter writer) {
 888                 writer.println("package " + converter.getPluginName() +"."+elementPackageName+";");
 889                 writer.println();
 890                 writer.println("import org.simantics.databoard.Bindings;");
 891                 writer.println("import org.simantics.db.Resource;");
 892                 writer.println("import org.simantics.db.ReadGraph;");
 893                 writer.println("import org.simantics.db.Statement;");
 894                 writer.println("import org.simantics.db.exception.DatabaseException;");
 895                 writer.println("import org.simantics.xml.sax.base.WriterElement;");
 896                 writer.println("import org.simantics.xml.sax.ontology.XMLResource;");
 897                 writer.println("import java.util.Collection;");
 898                 writer.println("import javax.xml.stream.XMLStreamException;");
 899                 writer.println("import javax.xml.stream.XMLStreamWriter;");
 900 //              if (!isList) {
 901 //              writer.println("import org.simantics.layer0.Layer0;");
 902 //          } else {
 903 //          writer.println("import java.util.Collections;");
 904 //              writer.println("import org.simantics.db.common.utils.ListUtils;");
 905 //              }
 906                 writer.println();
 907         }
 908
 909
 910
 911 }