Changeset 1519

Timestamp:

12/03/08 23:23:40 (5 weeks ago)

Author:

droos

Message:

more repeat instance validation and path API stuff

Location:

branches/dev-repeat/javarosa

Files:

• org.javarosa.core.model/src/org/javarosa/core/model/instance/DataModelTree.java (modified) (15 diffs)
• org.javarosa.core.model/src/org/javarosa/core/model/instance/QuestionDataElement.java (modified) (1 diff)
• org.javarosa.core.model/src/org/javarosa/core/model/instance/QuestionDataGroup.java (modified) (1 diff)
• org.javarosa.core.model/src/org/javarosa/core/model/instance/TreeElement.java (modified) (1 diff)
• org.javarosa.core.model/src/org/javarosa/core/model/instance/TreeReference.java (modified) (1 diff)
• org.javarosa.xform/src/org/javarosa/xform/parse/XFormParser.java (modified) (6 diffs)

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

@@ -20 +20 @@
 import org.javarosa.core.util.externalizable.ExtWrapTagged;
 import org.javarosa.core.util.externalizable.PrototypeFactory;
-import org.javarosa.model.xform.XPathReference;
-
-/**
- * DataModelTree is an implementation of IFormDataModel
- * that contains a Data Model which stores Question Answers
- * in an XML-style hierarchical tree, with no repeated
- * tree elements.
- *  
- * @author Clayton Sims
- *
- */
+
 public class DataModelTree implements IFormDataModel, IDRecordable {
 
         /** The root of this tree */
         private TreeElement root;
+        //represents '/'; always has one and only one child -- the top-level instance data node
+        //this node is never returned or manipulated directly
         
         /** The name for this data model */
@@ -43 +35 @@
         
         /** The ID of the form that this is a model for */
-        private int formIdReference;
+        private int formId;
         
         /** The date that this model was taken and recorded */
         private Date dateSaved;
         
-        public DataModelTree() { 
-        }
+        public DataModelTree() { }
         
         /**
@@ -57 +48 @@
          */
         public DataModelTree(TreeElement root) {
-                this.root = root;
+                setRoot(root);
         }
         
@@ -64 +55 @@
          * @param root The root of the tree for this data model.
          */
-        public void setRootElement(TreeElement root) {
-                this.root = root;
+        public void setRoot(TreeElement topLevel) {
+                root = new QuestionDataGroup(null, 0);
+                ((QuestionDataGroup)root).addChild(topLevel);
         }
         
@@ -71 +63 @@
          * @return This model's root tree element
          */
-        public TreeElement getRootElement() {
-                return root;
+        public TreeElement getRoot() {
+                return root == null ? null : (TreeElement)((QuestionDataGroup)root).getChildren().elementAt(0);
         }
 
@@ -85 +77 @@
         }
         
+        //IS THIS FUNCTION NEEDED?
         //create the specified node in the tree, creating all intermediary nodes
         //terminal = true: create element, false: create group (albeit empty)
@@ -91 +84 @@
         //  [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;
-                        }
-                }
-        }
+//      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
         
@@ -169 +162 @@
         }
         
+        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')
         public Vector expandReference (TreeReference ref) {
-                if (!ref.absolute)
+                if (!ref.isAbsolute())
                         return null;
                 
@@ -197 +204 @@
 
                         Vector children = new Vector();
-                        if (mult == TreeReference.INDEX_ALL) {
+                        if (mult == TreeReference.INDEX_UNBOUND) {
                                 int count = group.getMultiplicity(name);
                                 for (int i = 0; i < count; i++) {
@@ -225 +232 @@
         
         public TreeElement resolveReference (TreeReference ref) {
-                if (!ref.absolute)
+                if (!ref.isAbsolute())
                         return null;
                 
@@ -238 +245 @@
                         String name = (String)ref.names.elementAt(i);
                         int mult = ((Integer)ref.multiplicity.elementAt(i)).intValue();
-                        if (mult == TreeReference.INDEX_ALL) {
+                        if (mult == TreeReference.INDEX_UNBOUND) {
                                 if (group.children.size() == 1) {
                                         mult = 0;
@@ -252 +259 @@
                                 break;
                 }
-                return node;
+                return (node == root ? null : node); //never return a reference to '/'
         }
         
@@ -266 +273 @@
         }
         
+        //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;
+                
+        }
+        
         /**
          * Identifies whether the tree for this DataModel contains the given element.
@@ -289 +333 @@
         }
         
-        public void setFormReferenceId(int formIdReference) {
-                this.formIdReference = formIdReference;
+        public void setFormId(int formId) {
+                this.formId = formId;
         }
         
@@ -303 +347 @@
          * @see org.javarosa.core.model.IFormDataModel#getFormReferenceId()
          */
-        public int getFormReferenceId() {
-                return this.formIdReference;
+        public int getFormId() {
+                return this.formId;
         }
 

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

@@ -30 +30 @@
  */
 public class QuestionDataElement extends TreeElement {
-
+        boolean isAttribute = false;
+        
         /** The actual question data value */
         private IAnswerData value;

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

@@ -79 +79 @@
                 for (int i = 0; i < children.size(); i++) {
                         TreeElement child = (TreeElement)children.elementAt(i);
-                        if (child.getName().equals(name))
+                        if (child.getName().equals(name) && child.getMult() != TreeReference.INDEX_TEMPLATE)
                                 count++;
                 }

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

@@ -31 +31 @@
     protected Vector attributes;
 
+    public boolean repeatable = false;
+    
         /**
          * @return True if the element can contain subelements. False otherwise

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

@@ -43 +43 @@
                 names.addElement(name);
                 multiplicity.addElement(new Integer(index));
+        }
+        
+        public boolean isAbsolute () {
+                return refLevel == REF_ABSOLUTE;
         }
         

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

@@ -818 +818 @@
         //e is the top-level _data_ node of the instance (immediate (and only) child of <instance>)
         private static void parseInstance (FormDef f, Element e) {
-                TreeElement root = buildInstanceStructure(e, null, TreeReference.rootRef());
+                TreeElement root = buildInstanceStructure(e, null);
+                DataModelTree instanceModel = new DataModelTree(root);
+                instanceModel.setName(f.getName());
+                
+                processRepeats(instanceModel);
                 applyInstanceProperties(root);
                 loadInstanceData(e, root);
                 
                 //TreeElement root = parseInstanceNodes(e, TreeReference.rootRef()).getRoot();
-                DataModelTree instanceModel = new DataModelTree(root);
-                instanceModel.setName(f.getName());
+
                 f.setDataModel(instanceModel);
         }
 
         //create node structure
+        //flag repeats and process templating
         //evaluate binds and apply properties
         //load data based on data type
 
-        private static TreeElement buildInstanceStructure (Element node, QuestionDataGroup parent, TreeReference ref) {
+        //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) {
                 TreeElement element = null;
                 boolean isGroup;
@@ -839 +844 @@
                 boolean hasElements = false;
                 
+                //examine children
                 int numChildren = node.getChildCount();         
                 for (int i = 0; i < numChildren; i++) {
@@ -847 +853 @@
                 }
                 
+                //determine whether node is leaf or group
                 if (hasElements) {
                         isGroup = true;
@@ -856 +863 @@
                 }
 
+                //check for repeat templating
                 String name = node.getName();
-                int multiplicity = (parent == null ? 0 : parent.getMultiplicity(name));
-                
+                int multiplicity;
+                if (node.getAttributeValue(NAMESPACE_JAVAROSA, "template") != null) {
+                        multiplicity = TreeReference.INDEX_TEMPLATE;
+                        if (parent != null && parent.getChild(name, TreeReference.INDEX_TEMPLATE) != null) {
+                                throw new XFormParseException("More than one node declared as the template for the same repeated set");
+                        }
+                } else {
+                        multiplicity = (parent == null ? 0 : parent.getMultiplicity(name));
+                }
+                        
+                //create node; handle children
                 if (isGroup) {
                         element = new QuestionDataGroup(name, multiplicity);
@@ -874 +891 @@
                 if (node.getAttributeCount() > 0) {
                         for (int i = 0; i < node.getAttributeCount(); i++) {
-                                element.setAttribute(node.getAttributeNamespace(i), node.getAttributeName(i), node.getAttributeValue(i));
+                                String attrNamespace = node.getAttributeNamespace(i);
+                                String attrName = node.getAttributeName(i);
+                                if (attrNamespace.equals(NAMESPACE_JAVAROSA) && attrName.equals("template"))
+                                        continue;
+                                
+                                element.setAttribute(attrNamespace, attrName, node.getAttributeValue(i));
                                 //#if debug.output==verbose
                                 System.out.println(element.getName()+ " has added attr: "+element.getAttributeName(i)+"="+element.getAttributeValue(i));
@@ -882 +904 @@
                 
                 return element;
+        }
+        
+        private static void processRepeats (DataModelTree instance) {
+                Vector missingTemplates = new Vector();
+                
+                //flag all nodes identified by 'repeat' refs as repeatable
+                for (int i = 0; i < repeats.size(); i++) {
+                        TreeReference ref = (TreeReference)repeats.elementAt(i);
+                        Vector nodes = instance.expandReference(ref);
+                        for (int j = 0; j < nodes.size(); j++) {
+                                TreeReference nref = (TreeReference)nodes.elementAt(j);
+                                TreeElement node = instance.resolveReference(nref);
+                                node.repeatable = true;
+                        }
+                }
+                
+                //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);
+                        if (template == null) {
+                                missingTemplates.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
         }