Changeset 1520

Timestamp:

12/04/08 14:14:54 (5 weeks ago)

Author:

droos

Message:

more instance parsing and validation

Location:

branches/dev-repeat/javarosa

Files:

• org.javarosa.core.model/src/org/javarosa/core/model/instance/DataModelTree.java (modified) (8 diffs)
• org.javarosa.xform/src/org/javarosa/xform/parse/XFormParser.java (modified) (4 diffs)

branches/dev-repeat/javarosa/org.javarosa.core.model/src/org/javarosa/core/model/instance/DataModelTree.java

@@ -57 +57 @@
         public void setRoot(TreeElement topLevel) {
                 root = new QuestionDataGroup(null, 0);
-                ((QuestionDataGroup)root).addChild(topLevel);
+                if (topLevel != null)
+                        ((QuestionDataGroup)root).addChild(topLevel);
         }
         
@@ -64 +65 @@
          */
         public TreeElement getRoot() {
-                return root == null ? null : (TreeElement)((QuestionDataGroup)root).getChildren().elementAt(0);
+                if (root == null)
+                        return null;
+                else if (((QuestionDataGroup)root).children.size() == 0)
+                        return null;
+                else    
+                        return (TreeElement)((QuestionDataGroup)root).getChildren().elementAt(0);
         }
 
@@ -75 +81 @@
         public static TreeReference unpackReference (IDataReference ref) {
                 return (TreeReference)ref.getReference();
-        }
-        
-        //IS THIS FUNCTION NEEDED?
-        //create the specified node in the tree, creating all intermediary nodes
-        //terminal = true: create element, false: create group (albeit empty)
-        //at each step, if multiplicity =
-        //  ALL or count: always create a new node at the step
-        //  [0,count): use that specific node
-        //return a reference that unambiguously refers to the newly created node
-//      public TreeReference createNode (IDataReference ref, boolean terminal) {
-//              QuestionDataGroup node = (QuestionDataGroup)root;
-//              TreeReference tref = unpackReference(ref);
-//              
-//              for (int k = 0; k < tref.size(); k++) {
-//                      String name = (String)tref.names.elementAt(k);
-//                      int count = node.getMultiplicity(name);
-//                      int mult = ((Integer)tref.multiplicity.elementAt(k)).intValue();
-//                      
-//                      TreeElement child;
-//                      if (mult < count) {
-//                              //fetch existing
-//                              child = node.getChild(name, mult);
-//                              if (child == null)
-//                                      return null; //something wrong
-//                      } else if (mult == TreeReference.INDEX_UNBOUND || mult == count) {
-//                              //create new
-//                              if (k == tref.size() - 1 && terminal) {
-//                                      child = new QuestionDataElement(name, count, null);
-//                              } else {
-//                                      child = new QuestionDataGroup(name, count);
-//                              }
-//                              node.addChild(child);
-//                              tref.multiplicity.setElementAt(new Integer(count), k);
-//                      } else {
-//                              return null;
-//                      }
-//                      
-//                      if (k < tref.size() - 1) {
-//                              if (child instanceof QuestionDataElement) {
-//                                      throw new IllegalArgumentException();
-//                              }       
-//
-//                              node = (QuestionDataGroup)child;
-//                      }
-//              }
-//      }
-        //think this works
+        }       
         
         public boolean deleteNode (IDataReference ref) {
@@ -161 +121 @@
                 }
         }
-        
-        public TreeElement getTemplate (TreeReference ref) {
-                TreeReference tref = ref.clone(); //need to set all indexes to 0 first?
-                Vector nodes = explodeReference(ref);
-                if (nodes == null)
-                        return null;
-                
-                for (int i = 0; i < nodes.size(); i++) {
-                        TreeElement node = (TreeElement)nodes.elementAt(i);
-                        if (node.repeatable)
-                                tref.multiplicity.setElementAt(new Integer(TreeReference.INDEX_TEMPLATE), i);
-                }
-                return resolveReference(tref);
-        }
-        
-        //return a vector of TreeReferences that refer to all nodes in the instance (one ref per node) that match
-        //the passed-in TreeReference, accounting for all repeats.
-        //the returned refs will each unambiguously refer to a single node (i.e., no multiplicities will be 'ALL')
+
+        //take a ref that unambiguously refers to a single node and return that node
+        //return null if ref is ambiguous, node does not exist, ref is relative, or ref is '/'
+        //can be used to retrieve template nodes
+        public TreeElement resolveReference (TreeReference ref) {
+                if (!ref.isAbsolute())
+                        return null;
+                
+                TreeElement node = root;
+                for (int i = 0; i < ref.size(); i++) {
+                        if (!(node instanceof QuestionDataGroup)) {
+                                node = null;
+                                break;
+                        }
+                        QuestionDataGroup group = (QuestionDataGroup)node;
+                        
+                        String name = (String)ref.names.elementAt(i);
+                        int mult = ((Integer)ref.multiplicity.elementAt(i)).intValue();
+                        if (mult == TreeReference.INDEX_UNBOUND) {
+                                if (group.children.size() == 1) {
+                                        mult = 0;
+                                } else {
+                                        //reference is not unambiguous
+                                        node = null;
+                                        break;
+                                }
+                        }
+                        
+                        node = group.getChild(name, mult);
+                        if (node == null)
+                                break;
+                }
+                return (node == root ? null : node); //never return a reference to '/'
+        }
+
+        //same as resolveReference but return a vector containing all interstitial nodes: top-level instance data node first, and target node last
+        //returns null in all the same situations as resolveReference EXCEPT ref '/' will return empty vector
+        public Vector explodeReference (TreeReference ref) {
+                if (!ref.isAbsolute())
+                        return null;
+                
+                Vector nodes = new Vector();
+                TreeElement cur = root;
+                for (int i = 0; i < ref.size(); i++) {
+                        if (!(cur instanceof QuestionDataGroup)) {
+                                return null;
+                        }
+                        QuestionDataGroup group = (QuestionDataGroup)cur;
+                        
+                        String name = (String)ref.names.elementAt(i);
+                        int mult = ((Integer)ref.multiplicity.elementAt(i)).intValue();
+                        if (mult == TreeReference.INDEX_UNBOUND) {
+                                if (group.children.size() == 1) {
+                                        mult = 0;
+                                } else {
+                                        //reference is not unambiguous
+                                        return null;
+                                }
+                        }
+                        
+                        if (cur != root) {
+                                nodes.addElement(cur);
+                        }
+                        
+                        cur = group.getChild(name, mult);
+                        if (cur == null) {
+                                return null;
+                        }
+                }
+                return nodes;           
+        }
+
+        //take in a potentially-ambiguous ref, and return a vector of refs for all nodes that match the passed-in ref
+        //meaning, search out all repeated nodes that match the pattern of the passed-in ref
+        //every ref in the returned vector will be unambiguous (no index will ever be INDEX_UNBOUND)
+        //does not return template nodes when matching INDEX_UNBOUND, but will match templates when INDEX_TEMPLATE is explicitly set
+        //return null if ref is relative, otherwise return vector of refs (but vector will be empty is no refs match)
+        //'/' returns {'/'}
+        //can handle sub-repetitions (e.g., {/a[1]/b[1], /a[1]/b[2], /a[2]/b[1]})
         public Vector expandReference (TreeReference ref) {
                 if (!ref.isAbsolute())
@@ -188 +209 @@
         }
         
-        //helper function for expandReference(ref)
+        //recursive helper function for expandReference
         //sourceRef: original path we're matching against
         //node: current node that has matched the sourceRef thus far
@@ -231 +252 @@
         }
         
-        public TreeElement resolveReference (TreeReference ref) {
-                if (!ref.isAbsolute())
-                        return null;
-                
-                TreeElement node = root;
-                for (int i = 0; i < ref.size(); i++) {
-                        if (!(node instanceof QuestionDataGroup)) {
-                                node = null;
-                                break;
-                        }
-                        QuestionDataGroup group = (QuestionDataGroup)node;
-                        
-                        String name = (String)ref.names.elementAt(i);
-                        int mult = ((Integer)ref.multiplicity.elementAt(i)).intValue();
-                        if (mult == TreeReference.INDEX_UNBOUND) {
-                                if (group.children.size() == 1) {
-                                        mult = 0;
-                                } else {
-                                        //reference is not unambiguous
-                                        node = null;
-                                        break;
-                                }
-                        }
-                        
-                        node = group.getChild(name, mult);
-                        if (node == null)
-                                break;
-                }
-                return (node == root ? null : node); //never return a reference to '/'
+        //THIS WILL NOT WORK
+        //retrieve the template node corresponding to a given repeated node, if one exists
+        public TreeElement getTemplate (TreeReference ref) {
+                TreeReference tref = ref.clone();
+                for (int i = 0; i < tref.size(); i++) {
+                        tref.multiplicity.setElementAt(new Integer(0), i);
+                }
+                
+                Vector nodes = explodeReference(ref);
+                if (nodes == null)
+                        return null;
+                
+                for (int i = 0; i < nodes.size(); i++) {
+                        TreeElement node = (TreeElement)nodes.elementAt(i);
+                        if (node.repeatable)
+                                tref.multiplicity.setElementAt(new Integer(TreeReference.INDEX_TEMPLATE), i);
+                }
+                return resolveReference(tref);
         }
         
@@ -271 +281 @@
         public TreeElement resolveReference(IDataReference binding) {
                 return resolveReference(unpackReference(binding));
-        }
-        
-        //same as resolve reference but returns a vector containing all interstitial nodes
-        public Vector explodeReference (TreeReference ref) {
-                if (!ref.isAbsolute())
-                        return null;
-                
-                Vector nodes = new Vector();
-                TreeElement cur = root;
-                for (int i = 0; i < ref.size(); i++) {
-                        if (!(cur instanceof QuestionDataGroup)) {
-                                return null;
-                        }
-                        QuestionDataGroup group = (QuestionDataGroup)cur;
-                        
-                        String name = (String)ref.names.elementAt(i);
-                        int mult = ((Integer)ref.multiplicity.elementAt(i)).intValue();
-                        if (mult == TreeReference.INDEX_UNBOUND) {
-                                if (group.children.size() == 1) {
-                                        mult = 0;
-                                } else {
-                                        //reference is not unambiguous
-                                        return null;
-                                }
-                        }
-                        
-                        if (cur != root) {
-                                nodes.addElement(cur);
-                        }
-                        
-                        cur = group.getChild(name, mult);
-                        if (cur == null) {
-                                return null;
-                        }
-                }
-                return nodes;
-                
         }
         
@@ -414 +387 @@
         }
 }
+
+
+//IS THIS FUNCTION NEEDED?
+//create the specified node in the tree, creating all intermediary nodes
+//terminal = true: create element, false: create group (albeit empty)
+//at each step, if multiplicity =
+//  ALL or count: always create a new node at the step
+//  [0,count): use that specific node
+//return a reference that unambiguously refers to the newly created node
+//public TreeReference createNode (IDataReference ref, boolean terminal) {
+//      QuestionDataGroup node = (QuestionDataGroup)root;
+//      TreeReference tref = unpackReference(ref);
+//      
+//      for (int k = 0; k < tref.size(); k++) {
+//              String name = (String)tref.names.elementAt(k);
+//              int count = node.getMultiplicity(name);
+//              int mult = ((Integer)tref.multiplicity.elementAt(k)).intValue();
+//              
+//              TreeElement child;
+//              if (mult < count) {
+//                      //fetch existing
+//                      child = node.getChild(name, mult);
+//                      if (child == null)
+//                              return null; //something wrong
+//              } else if (mult == TreeReference.INDEX_UNBOUND || mult == count) {
+//                      //create new
+//                      if (k == tref.size() - 1 && terminal) {
+//                              child = new QuestionDataElement(name, count, null);
+//                      } else {
+//                              child = new QuestionDataGroup(name, count);
+//                      }
+//                      node.addChild(child);
+//                      tref.multiplicity.setElementAt(new Integer(count), k);
+//              } else {
+//                      return null;
+//              }
+//              
+//              if (k < tref.size() - 1) {
+//                      if (child instanceof QuestionDataElement) {
+//                              throw new IllegalArgumentException();
+//                      }       
+//
+//                      node = (QuestionDataGroup)child;
+//              }
+//      }
+//}
+//think this works

branches/dev-repeat/javarosa/org.javarosa.xform/src/org/javarosa/xform/parse/XFormParser.java

@@ -247 +247 @@
 
         private static void parseTitle (FormDef f, Element e) {
-                //Removed a line here about the form title not being null. Couldn't possibly think
-                //of why that would make sense. CTS - 7/21/2008
                 f.setName(getXMLText(e, true));
         }
@@ -835 +833 @@
         //evaluate binds and apply properties
         //load data based on data type
-
+        //verify bindings (also detect bindings too high; repeats too high already checked)
+        
         //parse instance hierarchy and turn into a skeleton model; ignoring data content, but respecting repeated nodes and 'template' flags
         private static TreeElement buildInstanceStructure (Element node, QuestionDataGroup parent) {
@@ -906 +905 @@
         }
         
+        //pre-process and clean up instance regarding repeats; in particular:
+        // 1) catalog which repeat template nodes are explicitly defined, and note which repeats bindings lack templates
+        // 2) remove template nodes that are not valid for a repeat binding
+        // 3) catch repeat bindings that are too high ('/' or '/data')
+        // #4) generate template nodes for repeat bindings that do not have one defined explicitly
+        // 5) give a stern warning for any repeated instance nodes that do not correspond to a repeat binding
+        // #6) verify that all sets of repeated nodes are homogeneous
+        // 7) flag all repeat-related nodes as repeatable
         private static void processRepeats (DataModelTree instance) {
-                Vector missingTemplates = new Vector();
-                
-                //flag all nodes identified by 'repeat' refs as repeatable
+                processTemplates(instance);
+                
+                //flag all nodes identified by repeat bindings as repeatable (template nodes already taken care of)
                 for (int i = 0; i < repeats.size(); i++) {
                         TreeReference ref = (TreeReference)repeats.elementAt(i);
@@ -920 +927 @@
                 }
                 
-                //locate all valid template nodes and flag them as repeatable as well
-                for (int i = 0; i < repeats.size(); i++) {
-                        TreeReference ref = (TreeReference)repeats.elementAt(i);
-                        TreeElement template = instance.getTemplate(ref);
+                checkDuplicateNodesAreRepeatable(instance.getRoot());
+                
+                //check repeat sets for homogeneity
+        }
+
+        private static void processTemplates (DataModelTree instance) {
+                DataModelTree repeatTree = buildRepeatTree(repeats, instance.getRoot().getName());
+                
+                Vector missingTemplates = new Vector(); //Vector<TreeReference>
+                checkRepeatsForTemplate(instance, repeatTree, missingTemplates);
+
+                removeInvalidTemplates(instance, repeatTree);
+                
+                
+                //if repeatables have no template node, duplicate first as template
+
+        }
+        
+        //build a pseudo-data model tree that describes the repeat structure of the instance
+        //result is a DataModelTree collapsed where all indexes are 0, and repeatable nodes are flagged as such
+        //return null if no repeats
+        //raises exception for repeats bound too highly
+        //ignores (invalid) repeats that bind outside the top-level instance data node
+        private static DataModelTree buildRepeatTree (Vector repeatRefs, String topLevelName) {
+                QuestionDataGroup root = new QuestionDataGroup(null, 0);
+                
+                for (int i = 0; i < repeatRefs.size(); i++) {
+                        TreeReference repeatRef = (TreeReference)repeatRefs.elementAt(i);
+                        if (repeatRef.size() <= 1) {
+                                throw new XFormParseException("Cannot repeat root instance node or top-level instance data node");
+                        }
+                        
+                        QuestionDataGroup cur = root;
+                        for (int j = 0; j < repeatRef.size(); j++) {
+                                String name = (String)repeatRef.names.elementAt(j);
+                                QuestionDataGroup child = (QuestionDataGroup)cur.getChild(name, 0);
+                                if (child == null) {
+                                        child = new QuestionDataGroup(name, 0);
+                                        cur.addChild(child);
+                                }
+                                
+                                cur = child;
+                                if (j == repeatRef.size() - 1) {
+                                        cur.repeatable = true;
+                                }                               
+                        }
+                }
+                
+                if (root.getChildren().size() == 0)
+                        return null;
+                else
+                        return new DataModelTree(root.getChild(topLevelName, 0));
+        }
+
+        //checks which repeat bindings have explicit template nodes; returns a vector of the bindings that do not
+        //for those that exist, flag them as repeatable
+        private static void checkRepeatsForTemplate (DataModelTree instance, DataModelTree instanceTree, Vector missingTemplates) {
+                checkRepeatsForTemplate((QuestionDataGroup)instanceTree.getRoot(), TreeReference.rootRef(), instance, missingTemplates);
+        }
+        
+        //helper function for checkRepeatsForTemplate
+        private static void checkRepeatsForTemplate (QuestionDataGroup repeatTreeNode, TreeReference ref, DataModelTree instance, Vector missing) {
+                String name = repeatTreeNode.getName();
+                int mult = (repeatTreeNode.repeatable ? TreeReference.INDEX_TEMPLATE : 0);
+                ref = ref.clone();
+                ref.add(name, mult);
+                
+                if (repeatTreeNode.repeatable) {
+                        TreeElement template = instance.resolveReference(ref);
                         if (template == null) {
-                                missingTemplates.addElement(ref);
+                                missing.addElement(ref);
                         } else {
                                 template.repeatable = true;
                         }
                 }
-                
-                //warn of any 'template' nodes that aren't repeatable
-                //warn of any delete incorrect sub-templates
-                //error for any repeated nodes that aren't repeatable
-                //if repeatables have no template node, duplicate first as template
-                //check repeat sets for homogeneity
+                        
+                for (int i = 0; i < repeatTreeNode.getChildren().size(); i++) {
+                        checkRepeatsForTemplate((QuestionDataGroup)repeatTreeNode.getChildren().elementAt(i), ref, instance, missing);
+                }
+        }
+        
+        //iterates through instance and removes template nodes that are not valid. a template is invalid if:
+        //  it is declared for a node that is not repeatable
+        //  it is for a repeat that is a child of another repeat and is not located within the parent's template node
+        private static void removeInvalidTemplates (DataModelTree instance, DataModelTree repeatTree) {
+                removeInvalidTemplates(instance.getRoot(), (QuestionDataGroup)repeatTree.getRoot(), true);
+        }
+        
+        //helper function for removeInvalidTemplates
+        private static boolean removeInvalidTemplates (TreeElement instanceNode, QuestionDataGroup repeatTreeNode, boolean templateAllowed) {
+                int mult = instanceNode.getMult();
+                boolean repeatable = (repeatTreeNode == null ? false : repeatTreeNode.repeatable);
+                
+                if (mult == TreeReference.INDEX_TEMPLATE) {
+                        if (!templateAllowed) {
+                                System.out.println("Warning: template nodes for sub-repeats must be located within the template nodes for all ancestor repeats; ignoring template...");
+                                return true;
+                        } else if (!repeatable) {
+                                System.out.println("Warning: template node found for ref that is not repeatable; ignoring...");
+                                return true;
+                        }
+                }
+                
+                if (repeatable && mult != TreeReference.INDEX_TEMPLATE)
+                        templateAllowed = false;
+                
+                if (instanceNode instanceof QuestionDataGroup) {
+                        QuestionDataGroup group = (QuestionDataGroup)instanceNode;
+                        for (int i = 0; i < group.getChildren().size(); i++) {
+                                TreeElement child = (TreeElement)group.getChildren().elementAt(i);
+                                QuestionDataGroup rchild = (repeatTreeNode == null ? null : (QuestionDataGroup)repeatTreeNode.getChild(instanceNode.getName(), 0));
+                                
+                                if (removeInvalidTemplates(child, rchild, templateAllowed)) {
+                                        group.getChildren().removeElementAt(i);
+                                        i--;
+                                }
+                        }
+
+                }
+                return false;
+        }
+        
+        private static void checkDuplicateNodesAreRepeatable (TreeElement node) {
+                int mult = node.getMult();
+                if (mult > 0) { //repeated node
+                        if (!node.repeatable) {
+                                System.out.println("Warning: repeated nodes detected that have no repeat binding in the form; DO NOT bind questions to these nodes!");
+                                //we could do a more comprehensive safety check in the future
+                        }
+                }
+                
+                if (node instanceof QuestionDataGroup) {
+                        QuestionDataGroup group = (QuestionDataGroup)node;
+                        for (int i = 0; i < group.getChildren().size(); i++) {
+                                checkDuplicateNodesAreRepeatable((TreeElement)group.getChildren().elementAt(i));
+                        }
+                }
         }