org.simantics.xml.sax/src/org/simantics/xml/sax/JavaGenerator.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.util.ArrayList;
   7 import java.util.HashMap;
   8 import java.util.List;
   9 import java.util.Map;
  10
  11 import javax.xml.namespace.QName;
  12
  13 import org.simantics.xml.sax.SchemaConversionBase.Inheritance;
  14 import org.simantics.xml.sax.SchemaConversionBase.RefType;
  15 import org.simantics.xml.sax.SchemaConversionBase.TypeEntry;
  16 import org.w3._2001.xmlschema.AttributeGroupRef;
  17 import org.w3._2001.xmlschema.Element;
  18 import org.w3._2001.xmlschema.Schema;
  19
  20 //public abstract class JavaGenerator extends SchemaConversionBase{
  21 public abstract class JavaGenerator implements SchemaConversionComponent {
  22
  23         String commentTag = "//";
  24
  25         Schema schema;
  26         String ontologyClassName;
  27         String ontologyUri;
  28         SchemaConverter converter;
  29         SchemaConversionBase base;
  30
  31         List<String> ruleClassNames = new ArrayList<String>();
  32
  33         String ontShort = "ONT";
  34         String name;
  35
  36         File importParserDir;
  37         String elementPackageName;
  38
  39         Map<SchemaObject, FileWriter> writers = new HashMap<SchemaObject, ImporterGenerator.FileWriter>();
  40
  41         public JavaGenerator(SchemaConverter converter, SchemaConversionBase base) {
  42                 this.converter = converter;
  43                 this.base = base;
  44
  45                 this.schema = base.schema;
  46                 this.ontologyClassName = base.className;
  47                 this.ontologyUri = base.ontologyURI;
  48                 this.converter = converter;
  49                 this.name = converter.name;
  50                 ontShort = converter.shortName;
  51                 ontShort +=".";
  52                 elementPackageName = name+getPackagePostFix();
  53         }
  54
  55         public String getElementPackageName() {
  56                 return elementPackageName;
  57         }
  58
  59
  60         protected PrintWriter createFile(File file) throws IOException {
  61                 if (!file.exists())
  62                         file.createNewFile();
  63                 PrintWriter writer = new PrintWriter(file);
  64                 for (String s : converter.getHeader()) {
  65                         writer.println(commentTag + " " + s);
  66                 }
  67                 writer.println();
  68                 return writer;
  69         }
  70
  71         protected String getValueGetterMethod(TypeEntry binding,String name) {
  72                 if (binding == null)
  73                         return name+".getValue()";
  74                 return binding.getValueGetterMethod(name);
  75         }
  76
  77         protected String getValueGetter(TypeEntry binding,String name) {
  78                 if (binding == null)
  79                         return name;
  80                 return binding.getValueGetter(name);
  81         }
  82
  83         protected String getValueGetter(TypeEntry binding) {
  84                 if (binding == null)
  85                         return "value";
  86                 return binding.getValueGetter();
  87         }
  88
  89         @Override
  90         public String getSimpleTypePrefix() {
  91                 return "SimpleTypes_";
  92         }
  93
  94         @Override
  95         public String getComplexTypePrefix() {
  96                 return "ComplexTypes_";
  97         }
  98
  99         @Override
 100         public String getAttributeGroupPrefix() {
 101                 return "AttributeGroups_";
 102         }
 103
 104         @Override
 105         public String handleChoice(SchemaObject parent, SchemaElement indicator, List<SchemaElement> elements, String name) {
 106                 String baseRelationName = getName(parent) + ".has" + name;
 107
 108 //              for (SchemaElement e : elements) {
 109 //                      Element localElement = e.getElement();
 110 //                      if (localElement.getName() != null) {
 111 //                              QName refType = localElement.getType();
 112 //                              if (refType != null)
 113 //                                      //handleIndicator(parent, indicator, e, false, name, refType);
 114 //                                      handleIndicator(parent, indicator, e, name, RefType.Type, baseRelationName);
 115 //                      } else if (localElement.getRef() != null) {
 116 //                              //QName refType = localElement.getRef();
 117 //                              //handleIndicator(parent, indicator, e, true, name, refType);
 118 //                              handleIndicator(parent, indicator, e, name, RefType.Reference, baseRelationName);
 119 //                      }
 120 //              }
 121
 122                 return baseRelationName;
 123         }
 124
 125         protected String getOntologyImport() {
 126                 return this.ontologyClassName+" " +ontShort.substring(0,ontShort.length()-1)+" = "+this.ontologyClassName+".getInstance(graph);";
 127         }
 128
 129         protected static class FileWriter {
 130                 public PrintWriter writer;
 131
 132                 public PrintWriter delayedWriter;
 133                 public PrintWriter delayedWriter2;
 134         }
 135
 136         protected  FileWriter getWriter(SchemaObject obj) {
 137                 SchemaObject s = obj;
 138                 while (s != null) {
 139                         FileWriter fw = writers.get(s);
 140                         if (fw != null)
 141                                 return fw;
 142                         s = s.getParent();
 143                 }
 144                 return null;
 145         }
 146
 147         @Override
 148         public String getName(SchemaObject obj) {
 149                 if (obj.getParent() == null) {
 150                         switch (obj.getType()) {
 151                         case COMPLEX_TYPE:
 152                                 return getComplexTypePrefix()+obj.getName();
 153                         case ELEMENT:
 154                                 return obj.getName();
 155                         case ATTRIBUTE_GROUP:
 156                                 return getAttributeGroupPrefix()+obj.getName();
 157                         case SIMPLE_TYPE:
 158                                 return getSimpleTypePrefix()+obj.getName();
 159                         }
 160                 } else {
 161                         SchemaObject o = obj;
 162                         SchemaObject prev = null;
 163                         String name = "";
 164                         while (o != null){
 165                                 if (o.getName() != null)
 166                                         name = o.getName()+"_"+name;
 167                                 prev = o;
 168                                 o = o.getParent();
 169                                 if (prev.getObj() instanceof AttributeGroupRef)
 170                                         o = null;
 171                         }
 172                         name = name.substring(0, name.length()-1);
 173                         switch (prev.getType()) {
 174                         case COMPLEX_TYPE:
 175                                 return getComplexTypePrefix()+name;
 176                         case ELEMENT:
 177                                 return name;
 178                         case ATTRIBUTE_GROUP:
 179                                 return getAttributeGroupPrefix()+name;
 180                         case SIMPLE_TYPE:
 181                                 return getSimpleTypePrefix()+name;
 182                         }
 183                 }
 184                 throw new RuntimeException();
 185         }
 186
 187         public String getName(SchemaObject obj, String rel) {
 188                 if (obj.getParent() == null) {
 189                         switch (obj.getType()) {
 190                         case COMPLEX_TYPE:
 191                                 return getComplexTypePrefix()+rel+obj.getName();
 192                         case ELEMENT:
 193                                 return rel+obj.getName();
 194                         case ATTRIBUTE_GROUP:
 195                                 return getAttributeGroupPrefix()+rel+obj.getName();
 196                         case SIMPLE_TYPE:
 197                                 return getSimpleTypePrefix()+rel+obj.getName();
 198                         }
 199                 } else {
 200                         SchemaObject o = obj;
 201                         SchemaObject prev = null;
 202                         String name = "";
 203                         while (o != null){
 204                                 if (o.getName() != null)
 205                                         name = o.getName()+"_"+name;
 206                                 prev = o;
 207                                 o = o.getParent();
 208                         }
 209                         name = name.substring(0, name.length()-1);
 210                         switch (prev.getType()) {
 211                         case COMPLEX_TYPE:
 212                                 return getComplexTypePrefix()+rel+name;
 213                         case ELEMENT:
 214                                 return rel+name;
 215                         case ATTRIBUTE_GROUP:
 216                                 return getAttributeGroupPrefix()+rel+name;
 217                         case SIMPLE_TYPE:
 218                                 return getSimpleTypePrefix()+rel+name;
 219                         }
 220                 }
 221                 throw new RuntimeException();
 222         }
 223
 224
 225
 226         protected void writeClass(PrintWriter writer,boolean abst, String elementId, String className, String baseClass, List<String> interfaces) {
 227                 writer.println("@SuppressWarnings(\"unused\")");
 228                 writer.print("public " +(abst ? "abstract " : "") + "class " + className + " extends "+baseClass);
 229                 if (interfaces.size() > 0) {
 230                         writer.print(" implements ");
 231                         for (int i = 0; i < interfaces.size(); i++) {
 232                                 writer.print(interfaces.get(i));
 233                                 if (i < interfaces.size() -1 )
 234                                         writer.print(",");
 235                         }
 236                 }
 237                 writer.println("{");
 238                 writer.println();
 239                 writer.println("   @Override");
 240                 writer.println("   public java.lang.String getElementId() {");
 241                 if (elementId != null)
 242                 writer.println("      return \""+elementId+"\";");
 243                 else // complex types cannot be parsed directly with name/id reference.
 244                 writer.println("      return null;");
 245                 writer.println("   }");
 246                 writer.println();
 247         }
 248
 249
 250         protected abstract void createReferenceIndicator(SchemaObject parent, RefType referenceType, String refName, String objectName, String primaryClassName, String secondaryClassName, boolean useElementList, boolean useOriginalList);
 251         protected abstract void createPrimitiveIndicator(SchemaObject parent, String refName, TypeEntry typeEntry, QName typeName);
 252         protected abstract void createElementIndicator(SchemaObject parent, boolean useElementList, String refName, String className, boolean useOriginalList);
 253
 254         protected abstract String getPackagePostFix();
 255         @Override
 256         public void handleIndicator(SchemaObject parent, SchemaElement indicator, SchemaElement element, String refName, RefType referenceType, String baseRelationName) {
 257                 String objectName;
 258                 if (referenceType != RefType.Element) {
 259                         QName refTypeName;
 260                         SchemaObject refObject = null;
 261                         if (referenceType == RefType.Type) {
 262                                 refTypeName = element.getElement().getType();
 263                                 if (refName == null)
 264                                         refName = base.getName(element.getElement());
 265                                 objectName = base.getName(element.getElement());
 266                                 refObject = this.base.getComplexType(refTypeName);
 267                                 if (refObject == null) this.base.getSimpleType(refTypeName);
 268                         } else {
 269                                 refTypeName = element.getElement().getRef();
 270                                 if (refName == null)
 271                                         refName = base.getName(refTypeName);
 272                                 objectName = refTypeName.getLocalPart();
 273                                 refObject = this.base.getElement(refTypeName);
 274                         }
 275
 276                         TypeEntry typeEntry = this.base.getTypeEntry(refTypeName);
 277                         if (typeEntry == null) {
 278                                 // prefer element reference over complex type reference
 279                                 String primaryClassName = null;
 280                                 String secondaryClassName = null;
 281                                 if (refObject != null) {
 282                                         primaryClassName = getName(refObject);
 283                                         if (refObject.getSc() != base) {
 284                                                 SchemaConverter con = refObject.getSc().converter;
 285                                                 primaryClassName = con.getPluginName() + "." + con.name +getPackagePostFix() + "." + primaryClassName;
 286                                         }
 287                                 }
 288                                 else if (this.base.getSimpleType(refTypeName) != null) {
 289                                         Inheritance inheritance = new Inheritance("");
 290                                         this.base.getAtomicTypeInheritance(refTypeName, inheritance);
 291                                         if (inheritance.atomicType != null) {
 292                                                 createPrimitiveIndicator(parent, refName, inheritance.atomicType, refTypeName);
 293                                                 return;
 294                                         }
 295                                         else {
 296                                                 throw new RuntimeException("No supported atomic type found for simple type " + refTypeName.toString());
 297                                         }
 298                                 }
 299                                 else {
 300                                         throw new RuntimeException("Type that is neither complex nor simple??");
 301                                 }
 302
 303                                 secondaryClassName = primaryClassName;
 304                                 boolean useElementList = this.base.useElementList(parent, indicator,element, referenceType == RefType.Reference, refName, refTypeName);
 305                                 boolean useOriginalList = this.base.useOriginalList(parent, indicator,element, referenceType == RefType.Reference, refName, refTypeName);
 306                                 createReferenceIndicator(parent, referenceType, refName, objectName, primaryClassName, secondaryClassName, useElementList, useOriginalList);
 307                         } else {
 308                                 createPrimitiveIndicator(parent, refName, typeEntry, refTypeName);
 309                         }
 310                 } else {
 311                         Element attrs= element.getElement();
 312                         SchemaObject obj = this.base.getWithObj(parent, attrs);
 313
 314                         String className = getName(obj);
 315                         if (refName == null)
 316                                  refName = base.getName(attrs);
 317
 318                         boolean useElementList = this.base.useElementList(parent, indicator,element, false, refName, new QName(obj.getName()));
 319                         boolean useOriginalList = this.base.useOriginalList(parent, indicator,element, false, refName, new QName(obj.getName()));
 320                         createElementIndicator(parent, useElementList, refName, className, useOriginalList);
 321                 }
 322         }
 323
 324 }