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