fixed ValidateChoices function for optional choices

src/lib/CodeGen.cpp

@@ -1063,16 +1063,52 @@ namespace tigl {
                                 cpp << "true // " << f.fieldName() << " is optional in choice";
                         }
 
-                        void operator()(const Choice& c) {
+                        void operator()(const Choice& ch) {
                             cpp << "(";
                             {
                                 Scope s(cpp);
-                                for (const auto& cc : c.options) {
-                                    (*this)(cc, c);
-                                    if (&cc != &c.options.back())
+                                boost::optional<Scope> additionalScope;
+
+                                if (ch.minOccurs == 0) {
+                                  cpp << "// all uninitialized is valid since choice is optional!";
+                                  cpp << "!(";
+                                    {
+                                        Scope s(cpp);
+
+                                        RecursiveColletor parentCollector;
+                                        parentCollector(ch);
+                                        auto& allIndices = parentCollector.indices;
+
+                                        auto unique = [](std::vector<std::size_t>& v) {
+                                            std::sort(std::begin(v), std::end(v));
+                                            const auto it = std::unique(std::begin(v), std::end(v));
+                                            v.erase(it, std::end(v));
+                                        };
+                                        unique(allIndices);
+
+                                        for (const auto& i : allIndices) {
+                                            writeIsFieldThere(cpp, c.fields[i]);
+                                            if (&i != &allIndices.back())
+                                                cpp << "||";
+                                        }
+                                    }
+                                    cpp << ")";
+                                    cpp << "||";
+                                    cpp << "(";
+                                    additionalScope.emplace(cpp);
+                                }
+
+                                for (const auto &ces : ch.options) {
+                                    (*this)(ces, ch);
+                                    if (&ces != &ch.options.back())
                                         cpp << "+";
                                 }
                                 cpp << "== 1";
+
+                                if (additionalScope) {
+                                  additionalScope.reset();
+                                  cpp << ")";
+                                }
                             }
                             cpp << ")";
                         }

src/lib/SchemaParser.cpp

@@ -64,6 +64,20 @@ namespace tigl {
                 // </choice>
                 Choice ch;
                 ch.xpath = xpath;
+
+                // minOccurs
+                if (!document.checkAttribute(xpath, "minOccurs"))
+                    ch.minOccurs = 1;
+                else {
+                  const auto minOccurs = document.textAttribute(xpath, "minOccurs");
+                  const auto minOccursInt = std::stoi(minOccurs);
+                  if (minOccursInt < 0)
+                      throw std::runtime_error("minOccurs is negative: " + xpath);
+                  else if (minOccursInt > 1)
+                      throw std::runtime_error("support for minOccurs>1 not implemented for choices yet: " + xpath);
+                  ch.minOccurs = minOccursInt;
+                }
+
                 document.forEachChild(xpath, "xsd:element", [&](const std::string& xpath) {
                     ch.elements.push_back(readElement(xpath, containingTypeName));
                 });

src/lib/SchemaParser.h

@@ -54,6 +54,7 @@ namespace tigl {
 
         struct Choice : XSDElement {
             std::vector<Variant<Element, Group, Choice, Sequence, Any>> elements;
+            unsigned int minOccurs;
         };
 
         struct SimpleContent : XSDElement {

src/lib/TypeSystem.cpp

@@ -117,6 +117,7 @@ namespace tigl {
                         const auto countBefore = members.size();
 
                         Choice choice;
+                        choice.minOccurs = c.minOccurs;
                         for (const auto& v : c.elements | boost::adaptors::indexed(1)) {
                             // collect members of one choice
                             auto indices = choiceIndices;

src/lib/TypeSystem.h

@@ -103,6 +103,7 @@ namespace tigl {
     using ChoiceElements = std::vector<boost::variant<ChoiceElement, boost::recursive_wrapper<Choice>>>;
 
     struct Choice {
+        unsigned int minOccurs;
         std::vector<ChoiceElements> options;
     };
 

test/data/optionalchoice/ref.cpp

@@ -158,34 +158,36 @@ namespace generated
     {
         return
         (
-            // all uninitialized is valid since choice is optional
-            !(
-                m_a_choice1.is_initialized()
-                ||
-                m_b_choice2.is_initialized()
-            )
-            ||
             (
-                (
-                    // mandatory elements of this choice must be there
+                // all uninitialized is valid since choice is optional!
+                !(
                     m_a_choice1.is_initialized()
-                    &&
-                    // elements of other choices must not be there
-                    !(
-                        m_b_choice2.is_initialized()
-                    )
+                    ||
+                    m_b_choice2.is_initialized()
                 )
-                +
+                ||
                 (
-                    // mandatory elements of this choice must be there
-                    m_b_choice2.is_initialized()
-                    &&
-                    // elements of other choices must not be there
-                    !(
+                    (
+                        // mandatory elements of this choice must be there
                         m_a_choice1.is_initialized()
+                        &&
+                        // elements of other choices must not be there
+                        !(
+                            m_b_choice2.is_initialized()
+                        )
+                    )
+                    +
+                    (
+                        // mandatory elements of this choice must be there
+                        m_b_choice2.is_initialized()
+                        &&
+                        // elements of other choices must not be there
+                        !(
+                            m_a_choice1.is_initialized()
+                        )
                     )
+                    == 1
                 )
-                == 1
             )
         )
         ;