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

   1 package org.simantics.xml.sax;\r
   2 \r
   3 import java.io.FileNotFoundException;\r
   4 import java.io.PrintWriter;\r
   5 import java.io.StringWriter;\r
   6 import java.util.ArrayList;\r
   7 import java.util.LinkedHashSet;\r
   8 import java.util.List;\r
   9 import java.util.Set;\r
  10 \r
  11 import javax.xml.namespace.QName;\r
  12 \r
  13 import org.simantics.utils.datastructures.BijectionMap;\r
  14 import org.simantics.xml.sax.SchemaObject.ObjectType;\r
  15 import org.simantics.xml.sax.configuration.AttributeComposition;\r
  16 import org.simantics.xml.sax.configuration.Configuration;\r
  17 import org.simantics.xml.sax.configuration.IDReference;\r
  18 import org.w3._2001.xmlschema.Annotated;\r
  19 import org.w3._2001.xmlschema.Attribute;\r
  20 import org.w3._2001.xmlschema.AttributeGroup;\r
  21 import org.w3._2001.xmlschema.Element;\r
  22 import org.w3._2001.xmlschema.LocalComplexType;\r
  23 import org.w3._2001.xmlschema.LocalSimpleType;\r
  24 import org.w3._2001.xmlschema.NamedAttributeGroup;\r
  25 import org.w3._2001.xmlschema.Restriction;\r
  26 import org.w3._2001.xmlschema.Schema;\r
  27 import org.w3._2001.xmlschema.SimpleType;\r
  28 import org.w3._2001.xmlschema.TopLevelAttribute;\r
  29 \r
  30 public class OntologyGenerator extends SchemaConversionBase {\r
  31         \r
  32         public OntologyGenerator(Configuration configuration) {\r
  33                 super(configuration);\r
  34         }\r
  35 \r
  36         String ontRoot = "ONT.";\r
  37         String commentTag = "//";\r
  38         \r
  39         Schema schema;\r
  40         String ontologyUri;\r
  41         String className;\r
  42         \r
  43         SchemaConverter converter;\r
  44         \r
  45         PrintWriter writer = null;\r
  46         \r
  47         \r
  48         \r
  49         \r
  50         \r
  51         public void createOntology(Schema schema, String ontologyName, String className, SchemaConverter converter) throws FileNotFoundException {\r
  52                 this.schema = schema;\r
  53                 this.converter = converter;\r
  54                 this.ontologyUri = ontologyName;\r
  55                 this.className = className;\r
  56                 \r
  57 //              for (OpenAttrs attrs : schema.getIncludeOrImportOrRedefine()) {\r
  58 //                      if (attrs instanceof Annotation) {\r
  59 //                              Annotation ann = (Annotation)attrs;\r
  60 //                              for (Object o : ann.getAppinfoOrDocumentation()) {\r
  61 //                                      if (o instanceof Documentation) {\r
  62 //                                              Documentation doc = (Documentation)o;\r
  63 //                                      } else if (o instanceof Appinfo) {\r
  64 //                                              Appinfo info = (Appinfo)o;\r
  65 //                                      }\r
  66 //                              }\r
  67 //                      }\r
  68 //              }\r
  69                 \r
  70                 \r
  71                 StringWriter stringWriter = null;\r
  72                 if (converter.getOntologyFile() == null) {\r
  73                         stringWriter = new StringWriter();\r
  74                         writer = new PrintWriter(stringWriter);\r
  75                 } else {\r
  76                         writer = new PrintWriter(converter.getOntologyFile());\r
  77                 }\r
  78         \r
  79                 handle(schema);\r
  80                 \r
  81                 writer.flush();\r
  82                 writer.close();\r
  83                 if (stringWriter != null)\r
  84                         System.out.println(stringWriter.toString());\r
  85         }\r
  86         \r
  87         protected void handle(Schema schema) {\r
  88                 String parts[] = ontologyUri.split("/");\r
  89                 String name = parts[parts.length-1];\r
  90                 ontRoot = name.substring(0, Math.min(3, name.length())).toUpperCase();\r
  91 \r
  92                 for (String s : converter.getHeader()) {\r
  93                         writer.println(commentTag + " " + s);   \r
  94                 }\r
  95                 writer.println();\r
  96                 writer.println("L0 = <http://www.simantics.org/Layer0-1.1>");\r
  97                 writer.println("XML = <http://www.simantics.org/XML-1.0>");\r
  98                 writer.println();\r
  99                 writer.println(ontRoot + " = <" + ontologyUri +"> : L0.Ontology");\r
 100                 writer.println("   @L0.new");\r
 101                 writer.println("   L0.HasResourceClass \"" + className +"\"");\r
 102                 writer.println();\r
 103                 writer.println();\r
 104                 \r
 105                 ontRoot += ".";\r
 106                 writer.println(ontRoot+"ComplexTypes : L0.Library");\r
 107                 writer.println(ontRoot+"AttributeGroups : L0.Library");\r
 108                 writer.println();\r
 109                 writer.println(commentTag + " Interpreted from schema");\r
 110                 writer.println();\r
 111                         \r
 112                 super.handle(schema);\r
 113         }\r
 114                 \r
 115         protected String getType(QName qtype) {\r
 116                 String ontType = getL0TypeFromPrimitiveType(qtype);\r
 117                 if (ontType != null)\r
 118                         return ontType;\r
 119                 else if (isComplexTypeRef(qtype.getLocalPart()))\r
 120                         return ontRoot+getComplexTypePrefix()+qtype.getLocalPart();\r
 121                 else if (isSimpleTypeRef(qtype.getLocalPart()))\r
 122                         return ontRoot+qtype.getLocalPart();\r
 123                 else if (isElementRef(qtype.getLocalPart()))\r
 124                         return ontRoot+qtype.getLocalPart();\r
 125                 else if (qtype.getPrefix() != null && qtype.getPrefix().length() > 0) {\r
 126                         return ontRoot+qtype.getPrefix()+qtype.getLocalPart();\r
 127                 }\r
 128                 throw new RuntimeException("Reference to unknown type " + qtype.getLocalPart());\r
 129         }\r
 130         \r
 131         @Override\r
 132         protected void handle(TopLevelAttribute topLevelAttribute) {\r
 133                 super.handle(topLevelAttribute);\r
 134                 writer.println();\r
 135         }\r
 136         \r
 137         @Override\r
 138         protected void handleSimpleType(SchemaObject topLevelSimpleType) {\r
 139                 super.handleSimpleType(topLevelSimpleType);\r
 140                 writer.println();\r
 141         }\r
 142         \r
 143         \r
 144         public String getComplexTypePrefix() {\r
 145                 return "ComplexTypes.";\r
 146         }\r
 147         \r
 148         public String getAttributeGroupPrefix() {\r
 149                 return "AttributeGroups.";\r
 150         }\r
 151         \r
 152         @Override\r
 153         protected void handle(SchemaObject parent, SchemaElement indicator, List<SchemaElement> elements) {\r
 154                 if (indicator.getType() == SchemaElement.ElementType.SEQUENCE || (indicator.getType() == SchemaElement.ElementType.CHOICE && indicator.getRestriction().many())) {\r
 155                         for (SchemaElement e : elements) {\r
 156                                 handle(parent, indicator, e);\r
 157                         }\r
 158                 } else if (indicator.getType() == SchemaElement.ElementType.CHOICE) {\r
 159                         String name = getChoiceName(elements);\r
 160                         boolean single = true;\r
 161                         for (SchemaElement e : elements) {\r
 162                                 if (e.getRestriction().many()) {\r
 163                                         single = false;\r
 164                                         break;\r
 165                                 }\r
 166                         }\r
 167                         String relationName = getName(parent)+".has"+name;\r
 168                         writer.print(relationName);\r
 169                         \r
 170                         List<String> types = new ArrayList<String>();\r
 171                         for (SchemaElement e : elements) {\r
 172                                 Element localElement = e.getElement();\r
 173                                 QName refType = null;\r
 174                                 String type = null;\r
 175                                 \r
 176                                 if (localElement.getName() != null) {\r
 177                                         refType = localElement.getType();\r
 178                                         type = getL0TypeFromPrimitiveType(refType);     \r
 179                                 } else if (localElement.getRef() != null) {\r
 180                                         refType = localElement.getRef();\r
 181                                         type = getL0TypeFromPrimitiveType(refType);\r
 182                                 }\r
 183                                 if (type == null) {\r
 184                                         SchemaObject obj = getWithName(parent, refType.getLocalPart());\r
 185                                         types.add(getName(obj,"has"));\r
 186                                 } \r
 187                         }\r
 188                         if (types.size() > 0) {\r
 189                                 for (String type : types) {\r
 190                                         writer.print(" <R " + type);\r
 191                                 }\r
 192                         } else {\r
 193                                 writer.print(" <R XML.hasElement");\r
 194                         }\r
 195                         \r
 196                         writer.println();\r
 197                         \r
 198                         for (SchemaElement e : elements) {\r
 199                                 Element localElement = e.getElement();\r
 200                                 QName refType = null;\r
 201                                 String type = null;\r
 202                                 if (localElement.getName() != null) {\r
 203                                         refType = localElement.getType();\r
 204                                         type = getType(refType);        \r
 205                                 } else if (localElement.getRef() != null) {\r
 206                                         refType = localElement.getRef();\r
 207                                         type = getType(refType);\r
 208                                 }\r
 209                                 if (type != null) {\r
 210                                         writer.println("   --> " + type);\r
 211                                 }\r
 212                         }\r
 213                         if (!single) {\r
 214                                 writer.println(ontRoot+name+ "List <T XML.ElementList");\r
 215                                 if (types.size() == 0) {\r
 216                                 writer.println(relationName+ "List <R XML.hasElementList : L0.FunctionalRelation");\r
 217                                 } else {\r
 218                                         writer.print(relationName+ "List");\r
 219                                         for (String type : types) {\r
 220                                                 writer.print(" <R " + type+"List");\r
 221                                         }\r
 222                                         writer.println(" : L0.FunctionalRelation");\r
 223                                 }\r
 224                                 writer.println("   --> " + ontRoot+name+"List");\r
 225                         }\r
 226                 }\r
 227                 \r
 228         }\r
 229         \r
 230         \r
 231         \r
 232         @Override\r
 233         protected void handleIndicator(SchemaObject parent, SchemaElement indicator, SchemaElement element, String refName, RefType refType) {\r
 234                 if (refType != refType.Element) {\r
 235                         QName referenceType = null;\r
 236                         if (refType == RefType.Type) {\r
 237                                 referenceType = element.getElement().getType();\r
 238                                 //refName = element.getElement().getName()\r
 239                                 SchemaObject eObj = elements.get(element.getElement());\r
 240                                 if (refName == null)\r
 241                                         refName = eObj.getName();\r
 242                         } else {\r
 243                                 referenceType = element.getElement().getRef();\r
 244                                 if (refName == null)\r
 245                                         refName = referenceType.getLocalPart();\r
 246                         }\r
 247                         String type = getL0TypeFromPrimitiveType(referenceType);\r
 248                         SchemaObject obj = null;\r
 249                         if (type == null) {\r
 250                                 obj = getWithName(parent, referenceType.getLocalPart());\r
 251                                 \r
 252                                 writer.println(getName(parent)+".has"+refName + " <R " +  getName(obj,"has"));\r
 253                                 writer.println("   --> " + getName(obj));\r
 254                         } else {\r
 255                                 writer.println(getName(parent)+".has"+refName + " <R XML.hasElement");\r
 256                                 writer.println("   --> " + getType(referenceType));\r
 257                         }\r
 258                         \r
 259                         if (useElementList(parent, indicator,element, refType == RefType.Reference, refName, referenceType)) {\r
 260                                 \r
 261                                 if (type == null) {\r
 262                                         writer.println(getName(parent)+"."+refName + "List <T XML.ElementList");\r
 263                                         writer.println(getName(parent)+".has"+refName + "List <R " +  getName(obj,"has")+"List : L0.FunctionalRelation");\r
 264                                 } else {\r
 265                                         writer.println(getName(parent)+"."+refName + "List <T XML.ElementList");\r
 266                                         writer.println(getName(parent)+".has"+refName + "List <R XML.hasElementList : L0.FunctionalRelation");  \r
 267                                 }\r
 268                         }\r
 269                 } else {\r
 270                         Element attrs = element.getElement();\r
 271                         SchemaObject obj = getWithObj(parent, attrs);\r
 272                         if (refName == null)\r
 273                                 refName = obj.getName();\r
 274                         \r
 275                         writer.println(getName(parent)+".has"+refName + " <R " + getName(obj,"has"));\r
 276                         writer.println("   --> " + getName(obj));\r
 277                         if (useElementList(parent, indicator,element, false, refName, new QName(obj.getName()))) {\r
 278                                 writer.println(getName(parent)+"."+refName + "List <T XML.ElementList");\r
 279                                 writer.println(getName(parent)+".has"+refName + "List <R " +  getName(obj,"has")+"List : L0.FunctionalRelation");\r
 280                         }\r
 281                 }\r
 282                 \r
 283         }\r
 284         \r
 285         @Override\r
 286         protected void handleIndicator(SchemaObject parent, SchemaElement indicator, SchemaElement any) {\r
 287                 \r
 288         }\r
 289                 \r
 290         @Override\r
 291         protected void handle(SchemaObject parent, Attribute attribute) {\r
 292                 String name = attribute.getName();\r
 293                 QName primitiveType = attribute.getType();\r
 294                 LocalSimpleType simpleType = attribute.getSimpleType();\r
 295                 QName ref = attribute.getRef();\r
 296                 \r
 297                 String relationName;\r
 298                 String relationType;\r
 299                 if (name != null) {\r
 300                         relationName = ontRoot+"has"+name;\r
 301                         if (parent != null)\r
 302                                 relationName = getName(parent)+".has"+name;\r
 303                         relationType = "XML.hasAttribute";\r
 304                 }\r
 305                 else if (ref != null && parent != null) {\r
 306                         relationName = getName(parent)+".has"+ref.getLocalPart();\r
 307                         relationType = ontRoot+"has"+ref.getLocalPart();\r
 308                 } else {\r
 309                         throw new RuntimeException();\r
 310                 }\r
 311                 boolean id = false;\r
 312                 String ontType = null;\r
 313                 if (primitiveType != null) {\r
 314                         ontType = getL0TypeFromPrimitiveType(primitiveType);\r
 315                         if (ontType != null) {\r
 316                                 id = getTypeEntry(primitiveType).id;\r
 317                                 if (id)\r
 318                                         relationType = "XML.hasID";\r
 319                         } else {\r
 320                                 \r
 321                         }\r
 322                 } else if (simpleType != null){\r
 323                         Restriction restriction = simpleType.getRestriction();\r
 324                         if (restriction == null || simpleType.getUnion() != null || simpleType.getName() != null || simpleType.getId() != null)\r
 325                                 throw new RuntimeException();\r
 326                         QName base = restriction.getBase();\r
 327                         \r
 328                         \r
 329                         ontType = getL0TypeFromPrimitiveType(base);\r
 330                         \r
 331 //                      for (Object facetWrap : restriction.getFacets()) {\r
 332 //                              JAXBElement<?> element = (JAXBElement<?>)facetWrap;\r
 333 //                              QName elementName = element.getName();\r
 334 //                              Facet facet = (Facet)element.getValue();        \r
 335 //                      }\r
 336                 }\r
 337                         \r
 338                 \r
 339                 \r
 340                 writer.println(relationName+ " <R " + relationType + ": L0.FunctionalRelation");\r
 341                 if (id) {\r
 342                         // no need to add range restriction\r
 343                 } else if (ontType != null) {\r
 344                         writer.println("   --> " + ontType);\r
 345                 } else if (primitiveType != null) {\r
 346                         writer.println("   <R "+ontRoot+"has"+primitiveType.getLocalPart());\r
 347                 }\r
 348         }\r
 349         \r
 350         @Override\r
 351         protected void handleAttributes(SchemaObject simpleTypeObj) {\r
 352 //              SchemaObject parent = simpleTypeObj.getParent();\r
 353 //              SimpleType simpleType = simpleTypeObj.getSimpleType();\r
 354 //              Restriction restriction = simpleType.getRestriction();\r
 355 //              QName base = restriction.getBase();\r
 356 //              String ontType = getL0TypeFromPrimitiveType(base);\r
 357         }\r
 358         \r
 359         @Override\r
 360         protected void handle(SchemaObject parent, AttributeGroup attributeGroup) {\r
 361                 if (parent == null) {\r
 362                         NamedAttributeGroup group = (NamedAttributeGroup)attributeGroup;\r
 363                         writer.println(ontRoot+getAttributeGroupPrefix()+group.getName()+ " <T XML.AttributeGroup");\r
 364                         SchemaObject obj = new SchemaObject(parent,attributeGroup);\r
 365                         for (Annotated annotated : group.getAttributeOrAttributeGroup()) {\r
 366                                 if (annotated instanceof Attribute) {\r
 367                                         //handle(getAttributeGroupPrefix()+group.getName(),(Attribute)annotated);\r
 368                                         handle(obj,(Attribute)annotated);\r
 369                                 } else if (annotated instanceof AttributeGroup) {\r
 370                                         throw new RuntimeException("Cannot handle nested attribute groups");\r
 371                                 }\r
 372                         }\r
 373                 } else {\r
 374                         writer.println(getName(parent) +" L0.Inherits " + ontRoot + getAttributeGroupPrefix() + attributeGroup.getRef().getLocalPart());\r
 375                 }\r
 376                 \r
 377         }\r
 378         \r
 379         @Override\r
 380         protected void handleAttributeComposition(SchemaObject parent, AttributeComposition composition, BijectionMap<org.simantics.xml.sax.configuration.Attribute, Annotated> attributes) {\r
 381                 Attribute compositionAttribute = new Attribute();\r
 382                 compositionAttribute.setName(composition.getName());\r
 383                 QName type = new QName(CONVERSION_NS, composition.getType());\r
 384                 compositionAttribute.setType(type);\r
 385                 handle(parent, compositionAttribute);\r
 386         }\r
 387         \r
 388         @Override\r
 389         protected void handleSimpleType(SchemaObject parent, SchemaObject simpleTypeObj) {\r
 390                 SimpleType simpleType = simpleTypeObj.getSimpleType();\r
 391                 String name = simpleType.getName();\r
 392                 \r
 393                 org.w3._2001.xmlschema.List list = simpleType.getList();\r
 394                 if (list != null) {\r
 395                         // TODO : process restriction in lists\r
 396                         String relationName = ontRoot+"has"+name;\r
 397                         if (parent != null)\r
 398                                 relationName = getName(parent)+".has"+name;\r
 399                         writer.println(relationName+ " <R XML.hasAttribute : L0.FunctionalRelation");\r
 400                         \r
 401                         String ontType = getL0Type(new QName(SCHEMA_NS, "string"));\r
 402                         writer.println("   --> " + ontType);\r
 403                 } else {\r
 404                         Restriction restriction = simpleType.getRestriction();\r
 405                         if (restriction == null || simpleType.getUnion() != null || simpleType.getId() != null)\r
 406                                 throw new RuntimeException(simpleType.getName() + " restriction error");\r
 407                         QName base = restriction.getBase();\r
 408                         \r
 409                         String relationName = ontRoot+"has"+name;\r
 410                         if (parent != null)\r
 411                                 relationName = getName(parent)+".has"+name;\r
 412                         \r
 413                         writer.println(relationName+ " <R XML.hasAttribute : L0.FunctionalRelation");\r
 414                         \r
 415                         String ontType = getL0Type(base);\r
 416                         writer.println("   --> " + ontType);\r
 417                 }\r
 418         }\r
 419         \r
 420         @Override\r
 421         protected void handleComplexType(SchemaObject topLevelComplexType) {\r
 422                 String name = getName(topLevelComplexType);\r
 423 //              if (topLevelComplexType.getName().equals("Reference"))\r
 424 //                      System.out.println();\r
 425                 \r
 426                 String relationName = getName(topLevelComplexType,"has");//ontRoot+"has"+name;\r
 427                 \r
 428                 writer.println(relationName+ " <R XML.hasComplexType");\r
 429                 writer.println(relationName+ "List <R XML.hasElementList");\r
 430                 //writer.println("   --> " + ontRoot+getComplexTypePrefix()+name);\r
 431                 writer.println("   --> " + name);\r
 432                 writer.println();\r
 433 //              String baseType = "XML.ComplexType";\r
 434 //\r
 435 //              QName base = getComplexTypeBase(topLevelComplexType.getComplexType());\r
 436 //              if (base != null) {\r
 437 //                      baseType = getType(base);\r
 438 //              }\r
 439 //              base = getSimpleTypeBase(topLevelComplexType.getSimpleType());\r
 440 //              if (base != null) {\r
 441 //                      baseType = getType(base);\r
 442 //              }\r
 443                 Inheritance inheritance = getInheritance(topLevelComplexType);\r
 444                 \r
 445 //              writer.println(name+ " <T "+baseType);\r
 446                 \r
 447                 if(inheritance.type == InheritanceType.AtomicType) {\r
 448                         writer.println(name+ " <T "+inheritance.baseClass + " <T "+inheritance.atomicType.l0Type);\r
 449                 } else {\r
 450                         writer.println(name+ " <T "+inheritance.baseClass);\r
 451                 }\r
 452 //              if (!baseType.equals(inheritance.baseClass))\r
 453 //                      System.out.println();\r
 454                 super.handleComplexType(topLevelComplexType);\r
 455                 writer.println();\r
 456         }\r
 457         \r
 458         @Override\r
 459         protected void handleElement(SchemaObject elementObj) {\r
 460                 Element element = elementObj.getElement();\r
 461                 String name = getName(elementObj);//element.getName();\r
 462                 \r
 463                 if ("Text".equals(name))\r
 464                         System.out.println();\r
 465                 \r
 466                 String type = "XML.Element";\r
 467                 Set<String> types = new LinkedHashSet<String>();\r
 468                 if (element.getType() != null) {\r
 469                         types.add(getType(element.getType()));\r
 470                 }\r
 471                 QName base = getElementBase(element);\r
 472                 if (base != null) {\r
 473                         if (base.getNamespaceURI().equals(SCHEMA_NS)) {\r
 474                                 String l0Type = getL0Type(base);\r
 475                                 if (l0Type == null)\r
 476                                         throw new RuntimeException("Cannot get L0 type for " + base.getLocalPart());\r
 477                                 types.add(l0Type);\r
 478                         } else if (isElementRef(base.getLocalPart()))\r
 479                                 types.add(ontRoot+base.getLocalPart());\r
 480                         else\r
 481                                 types.add(ontRoot+getComplexTypePrefix()+base.getLocalPart());\r
 482                 }\r
 483                 QName substitution = element.getSubstitutionGroup();\r
 484                 if (substitution != null) {\r
 485                         if (isElementRef(substitution.getLocalPart()))\r
 486                                 types.add(ontRoot+substitution.getLocalPart());\r
 487                         else\r
 488                                 types.add( ontRoot+getComplexTypePrefix()+substitution.getLocalPart());\r
 489                 }\r
 490                 for (String t : types) {\r
 491                         type += " <T " + t;\r
 492                 }\r
 493 \r
 494                 String relationName =  getName(elementObj,"has");//ontRoot+"has"+name;\r
 495 //              if (elementObj.getParent() != null) {\r
 496 //                      //relationName = ontRoot+getComplexTypePrefix()+"has"+name.substring(getComplexTypePrefix().length());\r
 497 //                      relationName = ontRoot+getName(elementObj.getParent()) + "has"+element.getName();\r
 498 //              }\r
 499                 writer.println(relationName+ " <R XML.hasElement");\r
 500                 writer.println(relationName+ "List <R XML.hasElementList");\r
 501                 \r
 502                 writer.println(name+ " <T "+type);\r
 503                 \r
 504                 LocalComplexType complexType = element.getComplexType();\r
 505                 LocalSimpleType simpleType = element.getSimpleType();\r
 506                 \r
 507                 if (complexType != null) {\r
 508                         SchemaObject complexTypeObj = complexTypes.get(complexType);\r
 509                         handleElementComplexTypeAttributes(complexTypeObj);\r
 510                         handleComplexTypeExtension(complexTypeObj);\r
 511                 } else if (simpleType != null) {\r
 512                         SchemaObject simpleTypeObj = simpleTypes.get(simpleType);\r
 513                         handleElementSimpleTypeAttributes(simpleTypeObj);\r
 514                 }\r
 515                 \r
 516                 List<IDReference> references = getIDReferences(element);\r
 517         \r
 518                 for (IDReference ref : references) {\r
 519                         writer.println(name+"."+ref.getReference().getName()+ " <R XML.hasReference");\r
 520                 }\r
 521                 \r
 522                 writer.println();\r
 523         }\r
 524         \r
 525         @Override\r
 526         protected String getBaseClass(ObjectType type) {\r
 527                 if (type == ObjectType.ELEMENT)\r
 528                         return "XML.Element";\r
 529                 if (type == ObjectType.COMPLEX_TYPE)\r
 530                         return "XML.ComplexType";\r
 531                 throw new RuntimeException("ObjectType " + type + " has no base class");\r
 532         }\r
 533         \r
 534         public String getName(SchemaObject obj) {\r
 535                 if (obj.getParent() == null) {\r
 536                         switch (obj.getType()) {\r
 537                         case COMPLEX_TYPE:\r
 538                                 return ontRoot+getComplexTypePrefix()+obj.getName();\r
 539                         case ELEMENT:\r
 540                                 return ontRoot+obj.getName();\r
 541                         case ATTRIBUTE_GROUP:\r
 542                                 return ontRoot+getAttributeGroupPrefix()+obj.getName();\r
 543                         case SIMPLE_TYPE:\r
 544                                 return ontRoot+obj.getName();\r
 545                         }\r
 546                 } else {\r
 547                         SchemaObject o = obj;\r
 548                         SchemaObject prev = null;\r
 549                         String name = "";\r
 550                         while (o != null){\r
 551                                 if (o.getName() != null)\r
 552                                         name = o.getName()+"."+name;\r
 553                                 prev = o;\r
 554                                 o = o.getParent();\r
 555                         }\r
 556                         name = name.substring(0, name.length()-1);\r
 557                         switch (prev.getType()) {\r
 558                         case COMPLEX_TYPE:\r
 559                                 return ontRoot+getComplexTypePrefix()+name;\r
 560                         case ELEMENT:\r
 561                                 return ontRoot+name;\r
 562                         case ATTRIBUTE_GROUP:\r
 563                                 return ontRoot+getAttributeGroupPrefix()+name;\r
 564                         case SIMPLE_TYPE:\r
 565                                 return ontRoot+name;\r
 566                         }\r
 567                 }\r
 568                 throw new RuntimeException();\r
 569                 \r
 570         }\r
 571         \r
 572         public String getName(SchemaObject obj, String rel) {\r
 573                 if (obj.getParent() == null) {\r
 574                         switch (obj.getType()) {\r
 575                         case COMPLEX_TYPE:\r
 576                                 return ontRoot+getComplexTypePrefix()+rel+obj.getName();\r
 577                         case ELEMENT:\r
 578                                 return ontRoot+rel+obj.getName();\r
 579                         case ATTRIBUTE_GROUP:\r
 580                                 return ontRoot+getAttributeGroupPrefix()+rel+obj.getName();\r
 581                         case SIMPLE_TYPE:\r
 582                                 return ontRoot+rel+obj.getName();\r
 583                         }\r
 584                 } else {\r
 585                         SchemaObject o = obj;\r
 586                         SchemaObject prev = null;\r
 587                         String name = "";\r
 588                         while (o != null){\r
 589                                 if (o.getName() != null)\r
 590                                         name = o.getName()+"."+name;\r
 591                                 prev = o;\r
 592                                 o = o.getParent();\r
 593                         }\r
 594                         name = name.substring(0, name.length()-1);\r
 595                         switch (prev.getType()) {\r
 596                         case COMPLEX_TYPE:\r
 597                                 return ontRoot+getComplexTypePrefix()+rel+name;\r
 598                         case ELEMENT:\r
 599                                 return ontRoot+rel+name;\r
 600                         case ATTRIBUTE_GROUP:\r
 601                                 return ontRoot+getAttributeGroupPrefix()+rel+name;\r
 602                         case SIMPLE_TYPE:\r
 603                                 return ontRoot+rel+name;\r
 604                         }\r
 605                 }\r
 606                 throw new RuntimeException();\r
 607                 \r
 608         }\r
 609         \r
 610         \r
 611 }\r