Changeset 126

Timestamp:

11/21/07 15:30:43 (9 months ago)

Author:

callan

Message:

Support a few further things that Curtis needs:

• Accesors for objects that follow OME XML reference naming conventions
  
• New convenience constructors that re-institute the org.openmicroscopy.xml semantics
  

Location:

Xml/xsd-fu/trunk

Files:

• fu.py (modified) (10 diffs)
• templates/Class.template (modified) (2 diffs)
• xsd-fu (modified) (3 diffs)

Xml/xsd-fu/trunk/fu.py

@@ -30 +30 @@
 import logging
 import re
+import os
+
 from generateDS.generateDS import *
 from xml import sax
@@ -44 +46 @@
         def now():
                 return datetime.now()
+
+# Default logger configuration
+#logging.basicConfig(level=logging.DEBUG,
+#                    format='%(asctime)s %(levelname)s %(message)s')
 
 # A global mapping from XSD Schema types and Java types
@@ -74 +80 @@
 DEFAULT_PACKAGE = "org.openmicroscopy.xml2007"
 
-# The base template for class processing.
+# The default template for class processing.
 CLASS_TEMPLATE = "templates/Class.template"
 
@@ -82 +88 @@
         """
         pass
+
+class ReferenceDelegate(object):
+        """
+        A "virtual" property delegate to be used with "reference" 
+        OMEModelProperty instances. This delegate conforms loosely to the same
+        interface as a delegate coming from generateDS.
+        """
+        def __init__(self, dataType):
+                self.name = dataType + "_BackReference"
+                self.dataType = dataType
+                # Ensures property code which is looking for elements or attributes
+                # which conform to an enumeration can function.
+                self.values = None
+        
+        def getMaxOccurs(self):
+                return 9999
+
+        def getMinOccurs(self):
+                return 0
+
+        def getType(self):
+                return self.dataType
+
+        def getName(self):
+                return self.name
         
 class OMEModelProperty(object):
         """
         An aggregate type representing either an OME XML Schema element or 
-        attribute.
+        attribute. This class equates conceptually to an instance variable which
+        may be of a singular type or a collection.
         """
         
@@ -93 +125 @@
                 self.delegate = delegate
                 self.isAttribute = False
+                self.isReference = False
 
         def _get_type(self):
@@ -129 +162 @@
                         return JAVA_TYPE_MAP[self.type]
                 except KeyError:
+                        # Hand back the type of references
+                        if self.isReference:
+                                return self.type
                         # Hand back the type of complex types
                         if not self.isAttribute and self.delegate.isComplex():
@@ -195 +231 @@
                 return klass(element, model)
         fromElement = classmethod(fromElement)
-        
+
+        def fromReference(klass, reference, model):
+                """
+                Instantiates a property from a "virtual" OME XML schema reference.
+                """
+                instance = klass(reference, model)
+                instance.isReference = True
+                return instance
+        fromReference = classmethod(fromReference)
 
 class OMEModelObject(object):
@@ -224 +268 @@
                 self.properties[name] = \
                         OMEModelProperty.fromElement(element, self.model)
-                        
+
         def _get_javaBase(self):
                 base = self.element.getBase()
@@ -316 +360 @@
                                 self.processTree(children, element)
 
+        def postProcessReferences(self):
+                """
+                Examines the list of objects in the model for instances that conform
+                to the OME XML Schema referential object naming conventions and
+                injects properties into referenced objects to provide back links.
+                """
+                references = dict()
+                for o in self.objects.values():
+                        for prop in o.properties.values():
+                                if prop.type[-3:] == "Ref":
+                                        shortName = prop.type[:-3]
+                                        if prop.type not in references:
+                                                references[shortName] = list()
+                                        references[shortName].append(o.name)
+
+                for o in self.objects.values():
+                        if o.name in references:
+                                for ref in references[o.name]:
+                                        delegate = ReferenceDelegate(ref)
+                                        prop = OMEModelProperty.fromReference(delegate, self)
+                                        o.properties[ref] = prop
+
         def process(klass, contentHandler):
                 """
@@ -326 +392 @@
                 model.topLevelSimpleTypes = contentHandler.topLevelSimpleTypes
                 model.processTree(elements)
+                model.postProcessReferences()
                 return model
         process = classmethod(process)

Xml/xsd-fu/trunk/templates/Class.template

@@ -39 +39 @@
 package ${fu.package};
 
+import ome.xml.DOMUtil;
+import ome.xml.OMEXMLNode;
+
 import java.util.Vector;
+import java.util.List;
+
 import org.w3c.dom.Element;
 
 public class ${klass.name}Node extends ${klass.javaBase}
 {
-        // -- Constructor --
+        // -- Constructors --
         
+        /** Constructs a ${klass.name} node with an associated DOM element. */
         public ${klass.name}Node(Element element)
         {
                 super(element);
         }
-        
+
+        /**
+         * Constructs a ${klass.name} node with an associated DOM element beneath
+         * a given parent.
+         */
+        public ${klass.name}Node(OMEXMLNode parent)
+        {
+                this(parent, true);
+        }
+
+        /**
+         * Constructs a ${klass.name} node with an associated DOM element beneath
+         * a given parent.
+         */
+        public ${klass.name}Node(OMEXMLNode parent, boolean attach)
+        {
+                super(DOMUtil.createChild(parent.getDOMElement(),
+                                          "${klass.name}", attach));
+        }
+
         // -- ${klass.name} API methods --
 {% for prop in klass.properties.values() %}\
   {% choose %}\
-    {% when prop.isAttribute and prop.type[-2:] == "ID" and prop.name not in fu.DO_NOT_PROCESS %}
+    {% when prop.isReference %}
+        // Virtual, inferred back reference ${prop.name}
+        public List get${prop.javaType}List()
+        {
+                return getReferringNodes("${prop.javaType}");
+        }
+        
+        public int count${prop.javaType}List()
+        {
+                return getReferringCount("${prop.javaType}");
+        }
+    {% end %}\
+    {% when prop.isAttribute and prop.type[-2:] == "ID" and \
+       prop.name not in fu.DO_NOT_PROCESS %}
         // Attribute which is an OME XML "ID"
         public ${prop.javaType} get${prop.name}()
@@ -141 +179 @@
         }
 }
+

Xml/xsd-fu/trunk/xsd-fu

@@ -77 +77 @@
         if outputDirectory is None:
                 usage("Output directory must be specified!")
+        if not os.path.exists(outputDirectory):
+            print "Output directory '%s' does not exist!" % outputDirectory
+            sys.exit(1)
 
         model = parseXmlSchema(args[0])
@@ -96 +99 @@
 
         model = parseXmlSchema("tmp/ome.xsd")
-        fu = Fu(outputDirectory, package)
+        fu = TemplateInfo(outputDirectory, package)
         template = NewTextTemplate(open(CLASS_TEMPLATE).read())
         for obj in model.objects.values():
-                if obj.name == "Experimenter":
+                if obj.name == "Laser":
                         print " +--", obj.name
                         for prop in obj.properties.values():
@@ -110 +113 @@
 #       debugMain()
         main()
+