bpmn++.h

Go to the documentation of this file.

// Automatically generated single header file
// schematic++ v0.4.0
#ifndef XMLObject_H
#define XMLObject_H
#include <memory>
#include <sstream>
#include <string>
#include <string_view>
#include <unordered_map>
#include <vector>
#include <optional>
 
#include <xercesc/dom/DOM.hpp>
 
/**
 * @brief The `XML` namespace contains classes representing XML-nodes defined in given XML-schema(s). 
 */
namespace XML {
 
class XMLObject;
 
typedef std::string ClassName;
typedef std::string ElementName;
typedef std::string TextContent;
typedef std::string Namespace;
typedef std::string AttributeName;
 
/**
 * @brief A struct representing the value of an XML-node attribute.
 *
 * The Value struct stores a value and provides implicit conversion and assignment operators
 * to facilitate easy conversion between different types and convenient assignment
 * of values.
 *
 * Example usage:
 * ```
 * Value value;
 * value = std::to_string("a_string");  // Assignment using a std::string.
 * value = true;                        // Assignment using a bool.
 * value = 42;                          // Assignment using an int.
 * value = 3.14;                        // Assignment using a double.
 *
 * std::string stringValue = value;     // Implicit conversion to std::string.
 * bool booleanValue = value;           // Implicit conversion to bool.
 * int integerValue = value;            // Implicit conversion to int.
 * double realValue = value;            // Implicit conversion to double.
 * ```
 */
struct Value {
  std::string value;
  operator std::string_view() const { return value; };
  operator std::string() const { return value; };
  operator bool() const { return (value == True); };
  operator int() const { try { return std::stoi(value); } catch(...) { throw std::runtime_error("Cannot convert '" + value + "' to int"); } };
  operator double() const { try { return std::stod(value); } catch(...) { throw std::runtime_error("Cannot convert '" + value + "' to double"); } };
  Value& operator=(const std::string& s) { value = s; return *this; };
  Value& operator=(bool b) { value = (b ? True : False); return *this; };
  Value& operator=(int i) { value = std::to_string(i); return *this; };
  Value& operator=(double d) { value = std::to_string(d); return *this; };
  Value(const std::string& s) : value(s) {};
  Value(bool b) : value(b ? True : False) {};
  Value(int i) : value(std::to_string(i)) {};
  Value(double d) : value(std::to_string(d)) {};
  inline static std::string True = "true";
  inline static std::string False = "false";
};
 
/**
 * @brief A struct representing an attribute of an XML-node.
 *
 * The `Attribute` struct stores information about the namespace, prefix, name, and
 * value of the attribute. 
 */
struct Attribute {
  Namespace xmlns;
  Namespace prefix;
  AttributeName name;
  Value value;
};
 
typedef std::vector<Attribute> Attributes;
typedef std::vector<std::unique_ptr<XMLObject>> Children;
 
/// @brief Template function used to store in factory
template<typename T> XMLObject* createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element) { return new T(xmlns, className, element, T::defaults); }
 
/// @brief Factory used to create instance depending on element name
typedef std::unordered_map<ElementName, XMLObject* (*)(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element)> Factory;
 
 
/**
 * @brief A class representing a node in an XML-tree.
 *
 * The XMLObject class allows to read and store an XML-tree. The root element can be created using
 * - @ref XMLObject::createFromStream(std::istream& xmlStream)
 * - @ref XMLObject::createFromString(const std::string& xmlString)
 * - @ref XMLObject::createFromFile(const std::string& filename)
 *
 * Each object has the following members:
 * - @ref xmlns : refers to the XML namespace
 * - @ref className : refers to the class it belong to
 * - @ref elementName : refers to the name used in the XML
 * - @ref prefix : refers to the namespace prefix in the XML
 * - @ref textContent : textual content of XML element without children
 * - @ref attributes : a list of attributes containing the namespace, prefix, attribute name,
 *   and attribute value
 * - @ref children : a list of child elements
 *
 * Derived classes with dedicated members for attributes and children  are automatically generated by
 * schematic++ according to respective XML schema definition(s).
 *
 * Each XMLObject can be converted to a string using @ref stringify() and printed to an output stream
 * using @ref operator<<(std::ostream& os, const XMLObject* obj) and
 * @ref operator<<(std::ostream& os, const XMLObject& obj) .
 */
class XMLObject {
 
public:
  /**
   * @brief Create an XMLObject from the input stream.
   *
   * @param xmlStream The input stream containing the XML data.
   * @return A pointer to the created XMLObject.
   * @throws std::runtime_error if parsing the XML fails.
   */
    static XMLObject* createFromStream(std::istream& xmlStream);
 
  /**
   * @brief Create an XMLObject from a string representation of XML.
   *
   * @param xmlString The string containing the XML data.
   * @return A pointer to the created XMLObject.
   * @throws std::runtime_error if parsing the XML fails.
   */
    static XMLObject* createFromString(const std::string& xmlString);
 
  /**
   * @brief Create an XMLObject from an XML file.
   *
   * @param filename The path to the XML file.
   * @return A pointer to the created XMLObject.
   * @throws std::runtime_error if loading the file or parsing the XML fails.
   */
    static XMLObject* createFromFile(const std::string& filename);
 
  virtual ~XMLObject() {};
 
protected:
  static XMLObject* createObject(const xercesc::DOMElement* element);
 
template<typename T> friend XMLObject* createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
 
protected:
  XMLObject(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
  inline static Factory factory;
public:
  /// @brief Returns a pointer of type T of the object.
  template<typename T> inline T* is() {
    return dynamic_cast<T*>(this);
  }
 
  template<typename T> inline const T* is() const {
    return dynamic_cast<const T*>(this);
  }
 
  /**
   * @brief Attempt to cast the current instance to the specified type T.
   * @return  A pointer to the casted object.
   * @throws std::runtime_error if the cast fails.
   */
  template<typename T> inline T* get() {
    T* ptr = dynamic_cast<T*>(this);
    if ( ptr == nullptr ) {
      throw std::runtime_error("XMLObject: Illegal cast");
    }
    return ptr;
  }
 
  /**
   * @brief Attempt to cast the current instance to the specified type T.
   * @return  A pointer to the casted object.
   * @throws std::runtime_error if the cast fails.
   */
  template<typename T> inline const T* get() const {
    const T* ptr = dynamic_cast<const T*>(this);
    if ( ptr == nullptr ) {
      throw std::runtime_error("XMLObject: Illegal cast");
    }
    return ptr;
  }
 
private:
  template<typename T>
  void findRecursive(std::vector<std::reference_wrapper<T> >& result, const Children& descendants)
  {
    for (auto& descendant : descendants) {
      if (descendant->is<T>()) {
        result.push_back(*descendant->get<T>());
      }
      findRecursive(result, descendant->children );
    }
  }
 
  template<typename T>
  void findRecursive(std::vector<std::reference_wrapper<const T> >& result, const Children& descendants) const
  {
    for (auto& descendant : descendants) {
      if (descendant->is<const T>()) {
        result.push_back(*descendant->get<const T>());
      }
      findRecursive(result, descendant->children );
    }
  }
 
public:
  /**
   * @brief Find all descendants of type T.
   *
   * @return A vector of references to descendants of type T.
   */
  template<typename T>
  std::vector<std::reference_wrapper<T> > find()
  {
    std::vector<std::reference_wrapper<T> > result;
    findRecursive(result, children);
    return result;
  }
 
  /**
   * @brief Find all descendants of type T.
   *
   * @return A vector of const references to descendants of type T.
   */
  template<typename T>
  std::vector<std::reference_wrapper<const T> > find() const
  {
    std::vector<std::reference_wrapper<const T> > result;
    findRecursive(result, children);
    return result;
  }
 
  Namespace xmlns;
  const ClassName className;
  Namespace prefix;
  ElementName elementName;
 
  TextContent textContent; ///< Textual content of XML element without children
  Children children; ///< Child nodes of the XML element
  Attributes attributes; /// Attributes of the XML element
    inline static const Attributes defaults = {};
 
  /**
   * @brief Convert the XMLObject and its children to a string representation.
   *
   * @return The string representation of the XMLObject.
   */
  std::string stringify() const;
 
  /**
   * @brief Creates formated string representing the XMLObject including its children.
   *
   * @return A formated string representing the XMLObject.
   */
  std::string format(std::string indentation = "\t", unsigned int depth = 0) const;
 
  /**
   * @brief Get a required child of type T.
   *
   * @return A reference to the required child.
   * @throws std::runtime_error if the required child is not found.
   */
  template<typename T> T& getRequiredChild() {
    for ( auto& child : children ) {
      if ( child->is<T>() ) {
        return *child->get<T>();
      }
    }
    throw std::runtime_error("Failed to get required child of element '" + elementName + "'");
  }
 
  /**
   * @brief Get an optional child of type T.
   *
   * @return An optional containing a reference to the optional child if found,
   *         or `std::nullopt` if the optional child is not found.
   */
  template<typename T> std::optional< std::reference_wrapper<T> > getOptionalChild() {
    for ( auto& child : children ) {
      if ( child->is<T>() ) {
        return *child->get<T>();
      }
    }
    return std::nullopt;
  }
 
  /**
   * @brief Get all children of type T.
   *
   * @return A vector of references to the children of type T.
   */
  template<typename T> std::vector< std::reference_wrapper<T> > getChildren() {
    std::vector< std::reference_wrapper<T> > result;
    for ( auto& child : children ) {
      if ( child->is<T>() ) {
        result.push_back(*child->get<T>());
      }
    }
    return result;
  }
 
  /**
   * @brief Get a required child with the specified element name.
   *
   * @param elementName The name of the child element without namespace prefix.
   * @return A reference to the required child.
   * @throws std::runtime_error if the required child is not found.
   */
  XMLObject& getRequiredChildByName(const ElementName& elementName);
 
  /**
   * @brief Get the optional child with the specified element name.
   *
   * @param elementName The name of the child element without namespace prefix.
   * @return An optional containing a reference to the optional child if found,
   *         or `std::nullopt` if the optional child is not found.
   */
  std::optional< std::reference_wrapper<XMLObject> > getOptionalChildByName(const ElementName& elementName);
 
  /**
   * @brief Get all children with the specified element name.
   *
   * @param elementName The name of the child elements without namespace prefix.
   * @return A vector of references to the children with the specified element name.
   */
  std::vector< std::reference_wrapper<XMLObject> > getChildrenByName(const ElementName& elementName);
 
  /**
   * @brief Get a required attribute with the specified attribute name.
   *
   * @param attributeName The name of the attribute without namespace prefix.
   * @return A reference to the required attribute.
   * @throws std::runtime_error if the required attribute is not found.
   */
  Attribute& getRequiredAttributeByName(const AttributeName& attributeName);
 
  /**
   * @brief Get an optional attribute with the specified attribute name.
   *
   * @param attributeName The name of the attribute without namespace prefix.
   * @return An optional containing a reference to the optional attribute if found,
   *         or `std::nullopt` if the optional attribute is not found.
   */
  std::optional< std::reference_wrapper<Attribute> > getOptionalAttributeByName(const AttributeName& attributeName);
 
 
};
 
/// @brief  Allows printing of stringified XML object
std::ostream& operator<<(std::ostream& os, const XMLObject* obj);
/// @brief  Allows printing of stringified XML object
std::ostream& operator<<(std::ostream& os, const XMLObject& obj);
 
} // end namespace XML
 
#endif // XML_H
#ifndef XML_bpmn_tBaseElement_H
#define XML_bpmn_tBaseElement_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tDocumentation;
class tExtensionElements;
 
/**
 * Overview:
 * - Element name:  tBaseElement
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - documentation : tDocumentation [0..*]
 * - extensionElements : tExtensionElements [0..1]
 * - id : ID [0..1]
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tBaseElement : public XMLObject {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tBaseElement"] = &createInstance<tBaseElement>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tBaseElement(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
    friend class tLane;
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::vector< std::reference_wrapper<tDocumentation> > documentation;
    std::optional< std::reference_wrapper<tExtensionElements> > extensionElements;
    std::optional< std::reference_wrapper<Attribute> > id; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tBaseElement_H
#ifndef XML_bpmn_baseElement_H
#define XML_bpmn_baseElement_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  baseElement
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class baseElement : public tBaseElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:baseElement"] = &createInstance<baseElement>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    baseElement(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_baseElement_H
#ifndef XML_bpmn_tArtifact_H
#define XML_bpmn_tArtifact_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tArtifact
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tArtifact : public tBaseElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tArtifact"] = &createInstance<tArtifact>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tArtifact(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
    friend class tCollaboration;
    friend class tProcess;
    friend class tSubChoreography;
    friend class tSubProcess;
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tArtifact_H
#ifndef XML_bpmn_artifact_H
#define XML_bpmn_artifact_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  artifact
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class artifact : public tArtifact {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:artifact"] = &createInstance<artifact>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    artifact(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_artifact_H
#ifndef XML_bpmn_tAssignment_H
#define XML_bpmn_tAssignment_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tExpression;
class tExpression;
 
/**
 * Overview:
 * - Element name:  tAssignment
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - from : tExpression [1..1]
 * - to : tExpression [1..1]
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tAssignment : public tBaseElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tAssignment"] = &createInstance<tAssignment>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tAssignment(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
    friend class tDataAssociation;
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    tExpression& from;
    tExpression& to;
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tAssignment_H
#ifndef XML_bpmn_assignment_H
#define XML_bpmn_assignment_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  assignment
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - from : tExpression [1..1] (from: tAssignment)
 * - to : tExpression [1..1] (from: tAssignment)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class assignment : public tAssignment {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:assignment"] = &createInstance<assignment>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    assignment(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_assignment_H
#ifndef XML_bpmn_tAssociation_H
#define XML_bpmn_tAssociation_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tAssociationDirection;
 
/**
 * Overview:
 * - Element name:  tAssociation
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - sourceRef : QName [1..1]
 * - targetRef : QName [1..1]
 * - associationDirection : tAssociationDirection [0..1]
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tAssociation : public tArtifact {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tAssociation"] = &createInstance<tAssociation>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tAssociation(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "associationDirection", .value = Value(std::string("None"))}
    };
 
    Attribute& sourceRef; ///< Attribute value can be expected to be of type 'std::string'
    Attribute& targetRef; ///< Attribute value can be expected to be of type 'std::string'
    std::optional< std::reference_wrapper<Attribute> > associationDirection; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tAssociation_H
#ifndef XML_bpmn_association_H
#define XML_bpmn_association_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  association
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - sourceRef : QName [1..1] (from: tAssociation)
 * - targetRef : QName [1..1] (from: tAssociation)
 * - associationDirection : tAssociationDirection [0..1] (from: tAssociation)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class association : public tAssociation {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:association"] = &createInstance<association>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    association(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "associationDirection", .value = Value(std::string("None"))}
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_association_H
#ifndef XML_bpmn_tAuditing_H
#define XML_bpmn_tAuditing_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tAuditing
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tAuditing : public tBaseElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tAuditing"] = &createInstance<tAuditing>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tAuditing(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
    friend class tFlowElement;
    friend class tProcess;
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tAuditing_H
#ifndef XML_bpmn_auditing_H
#define XML_bpmn_auditing_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  auditing
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class auditing : public tAuditing {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:auditing"] = &createInstance<auditing>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    auditing(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_auditing_H
#ifndef XML_bpmn_tBaseElementWithMixedContent_H
#define XML_bpmn_tBaseElementWithMixedContent_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tDocumentation;
class tExtensionElements;
 
/**
 * Overview:
 * - Element name:  tBaseElementWithMixedContent
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - documentation : tDocumentation [0..*]
 * - extensionElements : tExtensionElements [0..1]
 * - id : ID [0..1]
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tBaseElementWithMixedContent : public XMLObject {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tBaseElementWithMixedContent"] = &createInstance<tBaseElementWithMixedContent>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tBaseElementWithMixedContent(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::vector< std::reference_wrapper<tDocumentation> > documentation;
    std::optional< std::reference_wrapper<tExtensionElements> > extensionElements;
    std::optional< std::reference_wrapper<Attribute> > id; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tBaseElementWithMixedContent_H
#ifndef XML_bpmn_baseElementWithMixedContent_H
#define XML_bpmn_baseElementWithMixedContent_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  baseElementWithMixedContent
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - documentation : tDocumentation [0..*] (from: tBaseElementWithMixedContent)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElementWithMixedContent)
 * - id : ID [0..1] (from: tBaseElementWithMixedContent)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class baseElementWithMixedContent : public tBaseElementWithMixedContent {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:baseElementWithMixedContent"] = &createInstance<baseElementWithMixedContent>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    baseElementWithMixedContent(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_baseElementWithMixedContent_H
#ifndef XML_bpmn_tCategoryValue_H
#define XML_bpmn_tCategoryValue_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tCategoryValue
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - value : string [0..1]
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tCategoryValue : public tBaseElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tCategoryValue"] = &createInstance<tCategoryValue>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tCategoryValue(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
    friend class tCategory;
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::optional< std::reference_wrapper<Attribute> > value; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tCategoryValue_H
#ifndef XML_bpmn_categoryValue_H
#define XML_bpmn_categoryValue_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  categoryValue
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - value : string [0..1] (from: tCategoryValue)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class categoryValue : public tCategoryValue {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:categoryValue"] = &createInstance<categoryValue>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    categoryValue(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_categoryValue_H
#ifndef XML_bpmn_tComplexBehaviorDefinition_H
#define XML_bpmn_tComplexBehaviorDefinition_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tFormalExpression;
class tImplicitThrowEvent;
 
/**
 * Overview:
 * - Element name:  tComplexBehaviorDefinition
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - condition : tFormalExpression [1..1]
 * - event : tImplicitThrowEvent [0..1]
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tComplexBehaviorDefinition : public tBaseElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tComplexBehaviorDefinition"] = &createInstance<tComplexBehaviorDefinition>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tComplexBehaviorDefinition(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
    friend class tMultiInstanceLoopCharacteristics;
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    tFormalExpression& condition;
    std::optional< std::reference_wrapper<tImplicitThrowEvent> > event;
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tComplexBehaviorDefinition_H
#ifndef XML_bpmn_complexBehaviorDefinition_H
#define XML_bpmn_complexBehaviorDefinition_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  complexBehaviorDefinition
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - condition : tFormalExpression [1..1] (from: tComplexBehaviorDefinition)
 * - event : tImplicitThrowEvent [0..1] (from: tComplexBehaviorDefinition)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class complexBehaviorDefinition : public tComplexBehaviorDefinition {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:complexBehaviorDefinition"] = &createInstance<complexBehaviorDefinition>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    complexBehaviorDefinition(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_complexBehaviorDefinition_H
#ifndef XML_bpmn_tConversationAssociation_H
#define XML_bpmn_tConversationAssociation_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tConversationAssociation
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - innerConversationNodeRef : QName [1..1]
 * - outerConversationNodeRef : QName [1..1]
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tConversationAssociation : public tBaseElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tConversationAssociation"] = &createInstance<tConversationAssociation>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tConversationAssociation(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
    friend class tCollaboration;
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    Attribute& innerConversationNodeRef; ///< Attribute value can be expected to be of type 'std::string'
    Attribute& outerConversationNodeRef; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tConversationAssociation_H
#ifndef XML_bpmn_conversationAssociation_H
#define XML_bpmn_conversationAssociation_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  conversationAssociation
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - innerConversationNodeRef : QName [1..1] (from: tConversationAssociation)
 * - outerConversationNodeRef : QName [1..1] (from: tConversationAssociation)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class conversationAssociation : public tConversationAssociation {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:conversationAssociation"] = &createInstance<conversationAssociation>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    conversationAssociation(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_conversationAssociation_H
#ifndef XML_bpmn_tConversationLink_H
#define XML_bpmn_tConversationLink_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tConversationLink
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - name : string [0..1]
 * - sourceRef : QName [1..1]
 * - targetRef : QName [1..1]
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tConversationLink : public tBaseElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tConversationLink"] = &createInstance<tConversationLink>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tConversationLink(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
    friend class tCollaboration;
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::optional< std::reference_wrapper<Attribute> > name; ///< Attribute value can be expected to be of type 'std::string'
    Attribute& sourceRef; ///< Attribute value can be expected to be of type 'std::string'
    Attribute& targetRef; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tConversationLink_H
#ifndef XML_bpmn_conversationLink_H
#define XML_bpmn_conversationLink_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  conversationLink
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - name : string [0..1] (from: tConversationLink)
 * - sourceRef : QName [1..1] (from: tConversationLink)
 * - targetRef : QName [1..1] (from: tConversationLink)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class conversationLink : public tConversationLink {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:conversationLink"] = &createInstance<conversationLink>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    conversationLink(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_conversationLink_H
#ifndef XML_bpmn_tConversationNode_H
#define XML_bpmn_tConversationNode_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tCorrelationKey;
 
/**
 * Overview:
 * - Element name:  tConversationNode
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - participantRef : QName [0..*]
 * - messageFlowRef : QName [0..*]
 * - correlationKey : tCorrelationKey [0..*]
 * - name : string [0..1]
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tConversationNode : public tBaseElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tConversationNode"] = &createInstance<tConversationNode>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tConversationNode(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
    friend class tCollaboration;
    friend class tSubConversation;
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::vector< std::reference_wrapper<XMLObject> > participantRef;
    std::vector< std::reference_wrapper<XMLObject> > messageFlowRef;
    std::vector< std::reference_wrapper<tCorrelationKey> > correlationKey;
    std::optional< std::reference_wrapper<Attribute> > name; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tConversationNode_H
#ifndef XML_bpmn_conversationNode_H
#define XML_bpmn_conversationNode_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  conversationNode
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - participantRef : QName [0..*] (from: tConversationNode)
 * - messageFlowRef : QName [0..*] (from: tConversationNode)
 * - correlationKey : tCorrelationKey [0..*] (from: tConversationNode)
 * - name : string [0..1] (from: tConversationNode)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class conversationNode : public tConversationNode {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:conversationNode"] = &createInstance<conversationNode>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    conversationNode(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_conversationNode_H
#ifndef XML_bpmn_tCallConversation_H
#define XML_bpmn_tCallConversation_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tParticipantAssociation;
 
/**
 * Overview:
 * - Element name:  tCallConversation
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - participantAssociation : tParticipantAssociation [0..*]
 * - calledCollaborationRef : QName [0..1]
 * - participantRef : QName [0..*] (from: tConversationNode)
 * - messageFlowRef : QName [0..*] (from: tConversationNode)
 * - correlationKey : tCorrelationKey [0..*] (from: tConversationNode)
 * - name : string [0..1] (from: tConversationNode)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tCallConversation : public tConversationNode {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tCallConversation"] = &createInstance<tCallConversation>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tCallConversation(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::vector< std::reference_wrapper<tParticipantAssociation> > participantAssociation;
    std::optional< std::reference_wrapper<Attribute> > calledCollaborationRef; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tCallConversation_H
#ifndef XML_bpmn_callConversation_H
#define XML_bpmn_callConversation_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  callConversation
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - participantAssociation : tParticipantAssociation [0..*] (from: tCallConversation)
 * - calledCollaborationRef : QName [0..1] (from: tCallConversation)
 * - participantRef : QName [0..*] (from: tConversationNode)
 * - messageFlowRef : QName [0..*] (from: tConversationNode)
 * - correlationKey : tCorrelationKey [0..*] (from: tConversationNode)
 * - name : string [0..1] (from: tConversationNode)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class callConversation : public tCallConversation {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:callConversation"] = &createInstance<callConversation>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    callConversation(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_callConversation_H
#ifndef XML_bpmn_tConversation_H
#define XML_bpmn_tConversation_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tConversation
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - participantRef : QName [0..*] (from: tConversationNode)
 * - messageFlowRef : QName [0..*] (from: tConversationNode)
 * - correlationKey : tCorrelationKey [0..*] (from: tConversationNode)
 * - name : string [0..1] (from: tConversationNode)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tConversation : public tConversationNode {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tConversation"] = &createInstance<tConversation>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tConversation(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tConversation_H
#ifndef XML_bpmn_conversation_H
#define XML_bpmn_conversation_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  conversation
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - participantRef : QName [0..*] (from: tConversationNode)
 * - messageFlowRef : QName [0..*] (from: tConversationNode)
 * - correlationKey : tCorrelationKey [0..*] (from: tConversationNode)
 * - name : string [0..1] (from: tConversationNode)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class conversation : public tConversation {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:conversation"] = &createInstance<conversation>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    conversation(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_conversation_H
#ifndef XML_bpmn_tCorrelationKey_H
#define XML_bpmn_tCorrelationKey_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tCorrelationKey
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - correlationPropertyRef : QName [0..*]
 * - name : string [0..1]
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tCorrelationKey : public tBaseElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tCorrelationKey"] = &createInstance<tCorrelationKey>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tCorrelationKey(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
    friend class tChoreographyActivity;
    friend class tCollaboration;
    friend class tConversationNode;
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::vector< std::reference_wrapper<XMLObject> > correlationPropertyRef;
    std::optional< std::reference_wrapper<Attribute> > name; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tCorrelationKey_H
#ifndef XML_bpmn_correlationKey_H
#define XML_bpmn_correlationKey_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  correlationKey
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - correlationPropertyRef : QName [0..*] (from: tCorrelationKey)
 * - name : string [0..1] (from: tCorrelationKey)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class correlationKey : public tCorrelationKey {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:correlationKey"] = &createInstance<correlationKey>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    correlationKey(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_correlationKey_H
#ifndef XML_bpmn_tCorrelationPropertyBinding_H
#define XML_bpmn_tCorrelationPropertyBinding_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tFormalExpression;
 
/**
 * Overview:
 * - Element name:  tCorrelationPropertyBinding
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - dataPath : tFormalExpression [1..1]
 * - correlationPropertyRef : QName [1..1]
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tCorrelationPropertyBinding : public tBaseElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tCorrelationPropertyBinding"] = &createInstance<tCorrelationPropertyBinding>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tCorrelationPropertyBinding(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
    friend class tCorrelationSubscription;
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    tFormalExpression& dataPath;
    Attribute& correlationPropertyRef; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tCorrelationPropertyBinding_H
#ifndef XML_bpmn_correlationPropertyBinding_H
#define XML_bpmn_correlationPropertyBinding_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  correlationPropertyBinding
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - dataPath : tFormalExpression [1..1] (from: tCorrelationPropertyBinding)
 * - correlationPropertyRef : QName [1..1] (from: tCorrelationPropertyBinding)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class correlationPropertyBinding : public tCorrelationPropertyBinding {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:correlationPropertyBinding"] = &createInstance<correlationPropertyBinding>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    correlationPropertyBinding(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_correlationPropertyBinding_H
#ifndef XML_bpmn_tCorrelationPropertyRetrievalExpression_H
#define XML_bpmn_tCorrelationPropertyRetrievalExpression_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tFormalExpression;
 
/**
 * Overview:
 * - Element name:  tCorrelationPropertyRetrievalExpression
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - messagePath : tFormalExpression [1..1]
 * - messageRef : QName [1..1]
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tCorrelationPropertyRetrievalExpression : public tBaseElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tCorrelationPropertyRetrievalExpression"] = &createInstance<tCorrelationPropertyRetrievalExpression>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tCorrelationPropertyRetrievalExpression(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
    friend class tCorrelationProperty;
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    tFormalExpression& messagePath;
    Attribute& messageRef; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tCorrelationPropertyRetrievalExpression_H
#ifndef XML_bpmn_correlationPropertyRetrievalExpression_H
#define XML_bpmn_correlationPropertyRetrievalExpression_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  correlationPropertyRetrievalExpression
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - messagePath : tFormalExpression [1..1] (from: tCorrelationPropertyRetrievalExpression)
 * - messageRef : QName [1..1] (from: tCorrelationPropertyRetrievalExpression)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class correlationPropertyRetrievalExpression : public tCorrelationPropertyRetrievalExpression {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:correlationPropertyRetrievalExpression"] = &createInstance<correlationPropertyRetrievalExpression>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    correlationPropertyRetrievalExpression(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_correlationPropertyRetrievalExpression_H
#ifndef XML_bpmn_tCorrelationSubscription_H
#define XML_bpmn_tCorrelationSubscription_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tCorrelationPropertyBinding;
 
/**
 * Overview:
 * - Element name:  tCorrelationSubscription
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - correlationPropertyBinding : tCorrelationPropertyBinding [0..*]
 * - correlationKeyRef : QName [1..1]
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tCorrelationSubscription : public tBaseElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tCorrelationSubscription"] = &createInstance<tCorrelationSubscription>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tCorrelationSubscription(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
    friend class tProcess;
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::vector< std::reference_wrapper<tCorrelationPropertyBinding> > correlationPropertyBinding;
    Attribute& correlationKeyRef; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tCorrelationSubscription_H
#ifndef XML_bpmn_correlationSubscription_H
#define XML_bpmn_correlationSubscription_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  correlationSubscription
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - correlationPropertyBinding : tCorrelationPropertyBinding [0..*] (from: tCorrelationSubscription)
 * - correlationKeyRef : QName [1..1] (from: tCorrelationSubscription)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class correlationSubscription : public tCorrelationSubscription {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:correlationSubscription"] = &createInstance<correlationSubscription>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    correlationSubscription(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_correlationSubscription_H
#ifndef XML_bpmn_tDataAssociation_H
#define XML_bpmn_tDataAssociation_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tFormalExpression;
class tAssignment;
 
/**
 * Overview:
 * - Element name:  tDataAssociation
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - sourceRef : IDREF [0..*]
 * - targetRef : IDREF [1..1]
 * - transformation : tFormalExpression [0..1]
 * - assignment : tAssignment [0..*]
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tDataAssociation : public tBaseElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tDataAssociation"] = &createInstance<tDataAssociation>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tDataAssociation(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::vector< std::reference_wrapper<XMLObject> > sourceRef;
    XMLObject& targetRef;
    std::optional< std::reference_wrapper<tFormalExpression> > transformation;
    std::vector< std::reference_wrapper<tAssignment> > assignment;
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tDataAssociation_H
#ifndef XML_bpmn_dataAssociation_H
#define XML_bpmn_dataAssociation_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  dataAssociation
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - sourceRef : IDREF [0..*] (from: tDataAssociation)
 * - targetRef : IDREF [1..1] (from: tDataAssociation)
 * - transformation : tFormalExpression [0..1] (from: tDataAssociation)
 * - assignment : tAssignment [0..*] (from: tDataAssociation)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class dataAssociation : public tDataAssociation {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:dataAssociation"] = &createInstance<dataAssociation>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    dataAssociation(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_dataAssociation_H
#ifndef XML_bpmn_tDataInput_H
#define XML_bpmn_tDataInput_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tDataState;
 
/**
 * Overview:
 * - Element name:  tDataInput
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - dataState : tDataState [0..1]
 * - name : string [0..1]
 * - itemSubjectRef : QName [0..1]
 * - isCollection : boolean [0..1]
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tDataInput : public tBaseElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tDataInput"] = &createInstance<tDataInput>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tDataInput(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
    friend class tInputOutputSpecification;
    friend class tMultiInstanceLoopCharacteristics;
    friend class tThrowEvent;
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "isCollection", .value = Value(std::string("false"))}
    };
 
    std::optional< std::reference_wrapper<tDataState> > dataState;
    std::optional< std::reference_wrapper<Attribute> > name; ///< Attribute value can be expected to be of type 'std::string'
    std::optional< std::reference_wrapper<Attribute> > itemSubjectRef; ///< Attribute value can be expected to be of type 'std::string'
    std::optional< std::reference_wrapper<Attribute> > isCollection; ///< Attribute value can be expected to be of type 'bool'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tDataInput_H
#ifndef XML_bpmn_dataInput_H
#define XML_bpmn_dataInput_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  dataInput
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - dataState : tDataState [0..1] (from: tDataInput)
 * - name : string [0..1] (from: tDataInput)
 * - itemSubjectRef : QName [0..1] (from: tDataInput)
 * - isCollection : boolean [0..1] (from: tDataInput)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class dataInput : public tDataInput {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:dataInput"] = &createInstance<dataInput>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    dataInput(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "isCollection", .value = Value(std::string("false"))}
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_dataInput_H
#ifndef XML_bpmn_tDataInputAssociation_H
#define XML_bpmn_tDataInputAssociation_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tDataInputAssociation
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - sourceRef : IDREF [0..*] (from: tDataAssociation)
 * - targetRef : IDREF [1..1] (from: tDataAssociation)
 * - transformation : tFormalExpression [0..1] (from: tDataAssociation)
 * - assignment : tAssignment [0..*] (from: tDataAssociation)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tDataInputAssociation : public tDataAssociation {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tDataInputAssociation"] = &createInstance<tDataInputAssociation>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tDataInputAssociation(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
    friend class tActivity;
    friend class tThrowEvent;
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tDataInputAssociation_H
#ifndef XML_bpmn_dataInputAssociation_H
#define XML_bpmn_dataInputAssociation_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  dataInputAssociation
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - sourceRef : IDREF [0..*] (from: tDataAssociation)
 * - targetRef : IDREF [1..1] (from: tDataAssociation)
 * - transformation : tFormalExpression [0..1] (from: tDataAssociation)
 * - assignment : tAssignment [0..*] (from: tDataAssociation)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class dataInputAssociation : public tDataInputAssociation {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:dataInputAssociation"] = &createInstance<dataInputAssociation>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    dataInputAssociation(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_dataInputAssociation_H
#ifndef XML_bpmn_tDataOutput_H
#define XML_bpmn_tDataOutput_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tDataState;
 
/**
 * Overview:
 * - Element name:  tDataOutput
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - dataState : tDataState [0..1]
 * - name : string [0..1]
 * - itemSubjectRef : QName [0..1]
 * - isCollection : boolean [0..1]
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tDataOutput : public tBaseElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tDataOutput"] = &createInstance<tDataOutput>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tDataOutput(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
    friend class tCatchEvent;
    friend class tInputOutputSpecification;
    friend class tMultiInstanceLoopCharacteristics;
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "isCollection", .value = Value(std::string("false"))}
    };
 
    std::optional< std::reference_wrapper<tDataState> > dataState;
    std::optional< std::reference_wrapper<Attribute> > name; ///< Attribute value can be expected to be of type 'std::string'
    std::optional< std::reference_wrapper<Attribute> > itemSubjectRef; ///< Attribute value can be expected to be of type 'std::string'
    std::optional< std::reference_wrapper<Attribute> > isCollection; ///< Attribute value can be expected to be of type 'bool'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tDataOutput_H
#ifndef XML_bpmn_dataOutput_H
#define XML_bpmn_dataOutput_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  dataOutput
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - dataState : tDataState [0..1] (from: tDataOutput)
 * - name : string [0..1] (from: tDataOutput)
 * - itemSubjectRef : QName [0..1] (from: tDataOutput)
 * - isCollection : boolean [0..1] (from: tDataOutput)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class dataOutput : public tDataOutput {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:dataOutput"] = &createInstance<dataOutput>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    dataOutput(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "isCollection", .value = Value(std::string("false"))}
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_dataOutput_H
#ifndef XML_bpmn_tDataOutputAssociation_H
#define XML_bpmn_tDataOutputAssociation_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tDataOutputAssociation
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - sourceRef : IDREF [0..*] (from: tDataAssociation)
 * - targetRef : IDREF [1..1] (from: tDataAssociation)
 * - transformation : tFormalExpression [0..1] (from: tDataAssociation)
 * - assignment : tAssignment [0..*] (from: tDataAssociation)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tDataOutputAssociation : public tDataAssociation {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tDataOutputAssociation"] = &createInstance<tDataOutputAssociation>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tDataOutputAssociation(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
    friend class tActivity;
    friend class tCatchEvent;
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tDataOutputAssociation_H
#ifndef XML_bpmn_dataOutputAssociation_H
#define XML_bpmn_dataOutputAssociation_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  dataOutputAssociation
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - sourceRef : IDREF [0..*] (from: tDataAssociation)
 * - targetRef : IDREF [1..1] (from: tDataAssociation)
 * - transformation : tFormalExpression [0..1] (from: tDataAssociation)
 * - assignment : tAssignment [0..*] (from: tDataAssociation)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class dataOutputAssociation : public tDataOutputAssociation {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:dataOutputAssociation"] = &createInstance<dataOutputAssociation>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    dataOutputAssociation(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_dataOutputAssociation_H
#ifndef XML_bpmn_tDataState_H
#define XML_bpmn_tDataState_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tDataState
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - name : string [0..1]
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tDataState : public tBaseElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tDataState"] = &createInstance<tDataState>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tDataState(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
    friend class tDataInput;
    friend class tDataObject;
    friend class tDataObjectReference;
    friend class tDataOutput;
    friend class tDataStore;
    friend class tDataStoreReference;
    friend class tProperty;
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::optional< std::reference_wrapper<Attribute> > name; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tDataState_H
#ifndef XML_bpmn_dataState_H
#define XML_bpmn_dataState_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  dataState
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - name : string [0..1] (from: tDataState)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class dataState : public tDataState {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:dataState"] = &createInstance<dataState>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    dataState(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_dataState_H
#ifndef XML_bpmn_tDefinitions_H
#define XML_bpmn_tDefinitions_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tImport;
class tExtension;
class tRootElement;
class tProcess;
class BPMNDiagram;
class tRelationship;
 
/**
 * Overview:
 * - Element name:  tDefinitions
 * - XML-Schema:    xsd/BPMN20.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - import : tImport [0..*]
 * - extension : tExtension [0..*]
 * - rootElement : tRootElement [0..*]
 * - process : tProcess [0..*]
 * - bpmndi_BPMNDiagram : BPMNDiagram [0..*]
 * - relationship : tRelationship [0..*]
 * - id : ID [0..1]
 * - name : string [0..1]
 * - targetNamespace : anyURI [1..1]
 * - expressionLanguage : anyURI [0..1]
 * - typeLanguage : anyURI [0..1]
 * - exporter : string [0..1]
 * - exporterVersion : string [0..1]
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tDefinitions : public XMLObject {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tDefinitions"] = &createInstance<tDefinitions>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tDefinitions(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "expressionLanguage", .value = Value(std::string("http://www.w3.org/1999/XPath"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "typeLanguage", .value = Value(std::string("http://www.w3.org/2001/XMLSchema"))}
    };
 
    std::vector< std::reference_wrapper<tImport> > import;
    std::vector< std::reference_wrapper<tExtension> > extension;
    std::vector< std::reference_wrapper<tRootElement> > rootElement;
    std::vector< std::reference_wrapper<tProcess> > process;
    std::vector< std::reference_wrapper<BPMNDiagram> > bpmndi_BPMNDiagram;
    std::vector< std::reference_wrapper<tRelationship> > relationship;
    std::optional< std::reference_wrapper<Attribute> > id; ///< Attribute value can be expected to be of type 'std::string'
    std::optional< std::reference_wrapper<Attribute> > name; ///< Attribute value can be expected to be of type 'std::string'
    Attribute& targetNamespace; ///< Attribute value can be expected to be of type 'std::string'
    std::optional< std::reference_wrapper<Attribute> > expressionLanguage; ///< Attribute value can be expected to be of type 'std::string'
    std::optional< std::reference_wrapper<Attribute> > typeLanguage; ///< Attribute value can be expected to be of type 'std::string'
    std::optional< std::reference_wrapper<Attribute> > exporter; ///< Attribute value can be expected to be of type 'std::string'
    std::optional< std::reference_wrapper<Attribute> > exporterVersion; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tDefinitions_H
#ifndef XML_bpmn_definitions_H
#define XML_bpmn_definitions_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  definitions
 * - XML-Schema:    xsd/BPMN20.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - import : tImport [0..*] (from: tDefinitions)
 * - extension : tExtension [0..*] (from: tDefinitions)
 * - rootElement : tRootElement [0..*] (from: tDefinitions)
 * - process : tProcess [0..*] (from: tDefinitions)
 * - bpmndi_BPMNDiagram : BPMNDiagram [0..*] (from: tDefinitions)
 * - relationship : tRelationship [0..*] (from: tDefinitions)
 * - id : ID [0..1] (from: tDefinitions)
 * - name : string [0..1] (from: tDefinitions)
 * - targetNamespace : anyURI [1..1] (from: tDefinitions)
 * - expressionLanguage : anyURI [0..1] (from: tDefinitions)
 * - typeLanguage : anyURI [0..1] (from: tDefinitions)
 * - exporter : string [0..1] (from: tDefinitions)
 * - exporterVersion : string [0..1] (from: tDefinitions)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class definitions : public tDefinitions {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:definitions"] = &createInstance<definitions>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    definitions(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "expressionLanguage", .value = Value(std::string("http://www.w3.org/1999/XPath"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "typeLanguage", .value = Value(std::string("http://www.w3.org/2001/XMLSchema"))}
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_definitions_H
#ifndef XML_bpmn_tDocumentation_H
#define XML_bpmn_tDocumentation_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tDocumentation
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - id : ID [0..1]
 * - textFormat : string [0..1]
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tDocumentation : public XMLObject {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tDocumentation"] = &createInstance<tDocumentation>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tDocumentation(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
    friend class tBaseElement;
    friend class tBaseElementWithMixedContent;
    friend class tExtension;
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "textFormat", .value = Value(std::string("text/plain"))}
    };
 
    std::optional< std::reference_wrapper<Attribute> > id; ///< Attribute value can be expected to be of type 'std::string'
    std::optional< std::reference_wrapper<Attribute> > textFormat; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tDocumentation_H
#ifndef XML_bpmn_documentation_H
#define XML_bpmn_documentation_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  documentation
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - id : ID [0..1] (from: tDocumentation)
 * - textFormat : string [0..1] (from: tDocumentation)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class documentation : public tDocumentation {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:documentation"] = &createInstance<documentation>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    documentation(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "textFormat", .value = Value(std::string("text/plain"))}
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_documentation_H
#ifndef XML_bpmn_tExpression_H
#define XML_bpmn_tExpression_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tExpression
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - documentation : tDocumentation [0..*] (from: tBaseElementWithMixedContent)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElementWithMixedContent)
 * - id : ID [0..1] (from: tBaseElementWithMixedContent)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tExpression : public tBaseElementWithMixedContent {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tExpression"] = &createInstance<tExpression>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tExpression(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
    friend class tAdHocSubProcess;
    friend class tAssignment;
    friend class tComplexGateway;
    friend class tConditionalEventDefinition;
    friend class tMultiInstanceLoopCharacteristics;
    friend class tResourceAssignmentExpression;
    friend class tResourceParameterBinding;
    friend class tSequenceFlow;
    friend class tStandardLoopCharacteristics;
    friend class tTimerEventDefinition;
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tExpression_H
#ifndef XML_bpmn_expression_H
#define XML_bpmn_expression_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  expression
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - documentation : tDocumentation [0..*] (from: tBaseElementWithMixedContent)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElementWithMixedContent)
 * - id : ID [0..1] (from: tBaseElementWithMixedContent)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class expression : public tExpression {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:expression"] = &createInstance<expression>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    expression(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_expression_H
#ifndef XML_bpmn_tExtension_H
#define XML_bpmn_tExtension_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tDocumentation;
 
/**
 * Overview:
 * - Element name:  tExtension
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - documentation : tDocumentation [0..*]
 * - definition : QName [0..1]
 * - mustUnderstand : boolean [0..1]
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tExtension : public XMLObject {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tExtension"] = &createInstance<tExtension>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tExtension(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
    friend class tDefinitions;
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "mustUnderstand", .value = Value(std::string("false"))}
    };
 
    std::vector< std::reference_wrapper<tDocumentation> > documentation;
    std::optional< std::reference_wrapper<Attribute> > definition; ///< Attribute value can be expected to be of type 'std::string'
    std::optional< std::reference_wrapper<Attribute> > mustUnderstand; ///< Attribute value can be expected to be of type 'bool'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tExtension_H
#ifndef XML_bpmn_extension_H
#define XML_bpmn_extension_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  extension
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - documentation : tDocumentation [0..*] (from: tExtension)
 * - definition : QName [0..1] (from: tExtension)
 * - mustUnderstand : boolean [0..1] (from: tExtension)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class extension : public tExtension {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:extension"] = &createInstance<extension>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    extension(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "mustUnderstand", .value = Value(std::string("false"))}
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_extension_H
#ifndef XML_bpmn_tExtensionElements_H
#define XML_bpmn_tExtensionElements_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tExtensionElements
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tExtensionElements : public XMLObject {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tExtensionElements"] = &createInstance<tExtensionElements>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tExtensionElements(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
    friend class tBaseElement;
    friend class tBaseElementWithMixedContent;
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tExtensionElements_H
#ifndef XML_bpmn_extensionElements_H
#define XML_bpmn_extensionElements_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  extensionElements
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class extensionElements : public tExtensionElements {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:extensionElements"] = &createInstance<extensionElements>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    extensionElements(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_extensionElements_H
#ifndef XML_bpmn_tFlowElement_H
#define XML_bpmn_tFlowElement_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tAuditing;
class tMonitoring;
 
/**
 * Overview:
 * - Element name:  tFlowElement
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - auditing : tAuditing [0..1]
 * - monitoring : tMonitoring [0..1]
 * - categoryValueRef : QName [0..*]
 * - name : string [0..1]
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tFlowElement : public tBaseElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tFlowElement"] = &createInstance<tFlowElement>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tFlowElement(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
    friend class tChoreography;
    friend class tProcess;
    friend class tSubChoreography;
    friend class tSubProcess;
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::optional< std::reference_wrapper<tAuditing> > auditing;
    std::optional< std::reference_wrapper<tMonitoring> > monitoring;
    std::vector< std::reference_wrapper<XMLObject> > categoryValueRef;
    std::optional< std::reference_wrapper<Attribute> > name; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tFlowElement_H
#ifndef XML_bpmn_flowElement_H
#define XML_bpmn_flowElement_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  flowElement
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class flowElement : public tFlowElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:flowElement"] = &createInstance<flowElement>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    flowElement(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_flowElement_H
#ifndef XML_bpmn_tDataObject_H
#define XML_bpmn_tDataObject_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tDataState;
 
/**
 * Overview:
 * - Element name:  tDataObject
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - dataState : tDataState [0..1]
 * - itemSubjectRef : QName [0..1]
 * - isCollection : boolean [0..1]
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tDataObject : public tFlowElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tDataObject"] = &createInstance<tDataObject>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tDataObject(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "isCollection", .value = Value(std::string("false"))}
    };
 
    std::optional< std::reference_wrapper<tDataState> > dataState;
    std::optional< std::reference_wrapper<Attribute> > itemSubjectRef; ///< Attribute value can be expected to be of type 'std::string'
    std::optional< std::reference_wrapper<Attribute> > isCollection; ///< Attribute value can be expected to be of type 'bool'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tDataObject_H
#ifndef XML_bpmn_dataObject_H
#define XML_bpmn_dataObject_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  dataObject
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - dataState : tDataState [0..1] (from: tDataObject)
 * - itemSubjectRef : QName [0..1] (from: tDataObject)
 * - isCollection : boolean [0..1] (from: tDataObject)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class dataObject : public tDataObject {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:dataObject"] = &createInstance<dataObject>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    dataObject(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "isCollection", .value = Value(std::string("false"))}
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_dataObject_H
#ifndef XML_bpmn_tDataObjectReference_H
#define XML_bpmn_tDataObjectReference_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tDataState;
 
/**
 * Overview:
 * - Element name:  tDataObjectReference
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - dataState : tDataState [0..1]
 * - itemSubjectRef : QName [0..1]
 * - dataObjectRef : IDREF [0..1]
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tDataObjectReference : public tFlowElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tDataObjectReference"] = &createInstance<tDataObjectReference>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tDataObjectReference(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::optional< std::reference_wrapper<tDataState> > dataState;
    std::optional< std::reference_wrapper<Attribute> > itemSubjectRef; ///< Attribute value can be expected to be of type 'std::string'
    std::optional< std::reference_wrapper<Attribute> > dataObjectRef; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tDataObjectReference_H
#ifndef XML_bpmn_dataObjectReference_H
#define XML_bpmn_dataObjectReference_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  dataObjectReference
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - dataState : tDataState [0..1] (from: tDataObjectReference)
 * - itemSubjectRef : QName [0..1] (from: tDataObjectReference)
 * - dataObjectRef : IDREF [0..1] (from: tDataObjectReference)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class dataObjectReference : public tDataObjectReference {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:dataObjectReference"] = &createInstance<dataObjectReference>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    dataObjectReference(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_dataObjectReference_H
#ifndef XML_bpmn_tDataStoreReference_H
#define XML_bpmn_tDataStoreReference_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tDataState;
 
/**
 * Overview:
 * - Element name:  tDataStoreReference
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - dataState : tDataState [0..1]
 * - itemSubjectRef : QName [0..1]
 * - dataStoreRef : QName [0..1]
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tDataStoreReference : public tFlowElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tDataStoreReference"] = &createInstance<tDataStoreReference>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tDataStoreReference(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::optional< std::reference_wrapper<tDataState> > dataState;
    std::optional< std::reference_wrapper<Attribute> > itemSubjectRef; ///< Attribute value can be expected to be of type 'std::string'
    std::optional< std::reference_wrapper<Attribute> > dataStoreRef; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tDataStoreReference_H
#ifndef XML_bpmn_dataStoreReference_H
#define XML_bpmn_dataStoreReference_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  dataStoreReference
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - dataState : tDataState [0..1] (from: tDataStoreReference)
 * - itemSubjectRef : QName [0..1] (from: tDataStoreReference)
 * - dataStoreRef : QName [0..1] (from: tDataStoreReference)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class dataStoreReference : public tDataStoreReference {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:dataStoreReference"] = &createInstance<dataStoreReference>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    dataStoreReference(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_dataStoreReference_H
#ifndef XML_bpmn_tFlowNode_H
#define XML_bpmn_tFlowNode_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tFlowNode
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - incoming : QName [0..*]
 * - outgoing : QName [0..*]
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tFlowNode : public tFlowElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tFlowNode"] = &createInstance<tFlowNode>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tFlowNode(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::vector< std::reference_wrapper<XMLObject> > incoming;
    std::vector< std::reference_wrapper<XMLObject> > outgoing;
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tFlowNode_H
#ifndef XML_bpmn_flowNode_H
#define XML_bpmn_flowNode_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  flowNode
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class flowNode : public tFlowNode {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:flowNode"] = &createInstance<flowNode>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    flowNode(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_flowNode_H
#ifndef XML_bpmn_tActivity_H
#define XML_bpmn_tActivity_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tInputOutputSpecification;
class tProperty;
class tDataInputAssociation;
class tDataOutputAssociation;
class tResourceRole;
class tLoopCharacteristics;
 
/**
 * Overview:
 * - Element name:  tActivity
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - ioSpecification : tInputOutputSpecification [0..1]
 * - property : tProperty [0..*]
 * - dataInputAssociation : tDataInputAssociation [0..*]
 * - dataOutputAssociation : tDataOutputAssociation [0..*]
 * - resourceRole : tResourceRole [0..*]
 * - loopCharacteristics : tLoopCharacteristics [0..*]
 * - isForCompensation : boolean [0..1]
 * - startQuantity : integer [0..1]
 * - completionQuantity : integer [0..1]
 * - default : IDREF [0..1]
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tActivity : public tFlowNode {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tActivity"] = &createInstance<tActivity>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tActivity(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "isForCompensation", .value = Value(std::string("false"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "startQuantity", .value = Value(std::string("1"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "completionQuantity", .value = Value(std::string("1"))}
    };
 
    std::optional< std::reference_wrapper<tInputOutputSpecification> > ioSpecification;
    std::vector< std::reference_wrapper<tProperty> > property;
    std::vector< std::reference_wrapper<tDataInputAssociation> > dataInputAssociation;
    std::vector< std::reference_wrapper<tDataOutputAssociation> > dataOutputAssociation;
    std::vector< std::reference_wrapper<tResourceRole> > resourceRole;
    std::vector< std::reference_wrapper<tLoopCharacteristics> > loopCharacteristics;
    std::optional< std::reference_wrapper<Attribute> > isForCompensation; ///< Attribute value can be expected to be of type 'bool'
    std::optional< std::reference_wrapper<Attribute> > startQuantity; ///< Attribute value can be expected to be of type 'int'
    std::optional< std::reference_wrapper<Attribute> > completionQuantity; ///< Attribute value can be expected to be of type 'int'
    std::optional< std::reference_wrapper<Attribute> > default_; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tActivity_H
#ifndef XML_bpmn_activity_H
#define XML_bpmn_activity_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  activity
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - ioSpecification : tInputOutputSpecification [0..1] (from: tActivity)
 * - property : tProperty [0..*] (from: tActivity)
 * - dataInputAssociation : tDataInputAssociation [0..*] (from: tActivity)
 * - dataOutputAssociation : tDataOutputAssociation [0..*] (from: tActivity)
 * - resourceRole : tResourceRole [0..*] (from: tActivity)
 * - loopCharacteristics : tLoopCharacteristics [0..*] (from: tActivity)
 * - isForCompensation : boolean [0..1] (from: tActivity)
 * - startQuantity : integer [0..1] (from: tActivity)
 * - completionQuantity : integer [0..1] (from: tActivity)
 * - default : IDREF [0..1] (from: tActivity)
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class activity : public tActivity {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:activity"] = &createInstance<activity>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    activity(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "isForCompensation", .value = Value(std::string("false"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "startQuantity", .value = Value(std::string("1"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "completionQuantity", .value = Value(std::string("1"))}
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_activity_H
#ifndef XML_bpmn_tCallActivity_H
#define XML_bpmn_tCallActivity_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tCallActivity
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - calledElement : QName [0..1]
 * - ioSpecification : tInputOutputSpecification [0..1] (from: tActivity)
 * - property : tProperty [0..*] (from: tActivity)
 * - dataInputAssociation : tDataInputAssociation [0..*] (from: tActivity)
 * - dataOutputAssociation : tDataOutputAssociation [0..*] (from: tActivity)
 * - resourceRole : tResourceRole [0..*] (from: tActivity)
 * - loopCharacteristics : tLoopCharacteristics [0..*] (from: tActivity)
 * - isForCompensation : boolean [0..1] (from: tActivity)
 * - startQuantity : integer [0..1] (from: tActivity)
 * - completionQuantity : integer [0..1] (from: tActivity)
 * - default : IDREF [0..1] (from: tActivity)
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tCallActivity : public tActivity {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tCallActivity"] = &createInstance<tCallActivity>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tCallActivity(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "isForCompensation", .value = Value(std::string("false"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "startQuantity", .value = Value(std::string("1"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "completionQuantity", .value = Value(std::string("1"))}
    };
 
    std::optional< std::reference_wrapper<Attribute> > calledElement; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tCallActivity_H
#ifndef XML_bpmn_callActivity_H
#define XML_bpmn_callActivity_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  callActivity
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - calledElement : QName [0..1] (from: tCallActivity)
 * - ioSpecification : tInputOutputSpecification [0..1] (from: tActivity)
 * - property : tProperty [0..*] (from: tActivity)
 * - dataInputAssociation : tDataInputAssociation [0..*] (from: tActivity)
 * - dataOutputAssociation : tDataOutputAssociation [0..*] (from: tActivity)
 * - resourceRole : tResourceRole [0..*] (from: tActivity)
 * - loopCharacteristics : tLoopCharacteristics [0..*] (from: tActivity)
 * - isForCompensation : boolean [0..1] (from: tActivity)
 * - startQuantity : integer [0..1] (from: tActivity)
 * - completionQuantity : integer [0..1] (from: tActivity)
 * - default : IDREF [0..1] (from: tActivity)
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class callActivity : public tCallActivity {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:callActivity"] = &createInstance<callActivity>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    callActivity(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "isForCompensation", .value = Value(std::string("false"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "startQuantity", .value = Value(std::string("1"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "completionQuantity", .value = Value(std::string("1"))}
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_callActivity_H
#ifndef XML_bpmn_tChoreographyActivity_H
#define XML_bpmn_tChoreographyActivity_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tCorrelationKey;
class tChoreographyLoopType;
 
/**
 * Overview:
 * - Element name:  tChoreographyActivity
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - participantRef : QName [2..*]
 * - correlationKey : tCorrelationKey [0..*]
 * - initiatingParticipantRef : QName [1..1]
 * - loopType : tChoreographyLoopType [0..1]
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tChoreographyActivity : public tFlowNode {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tChoreographyActivity"] = &createInstance<tChoreographyActivity>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tChoreographyActivity(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "loopType", .value = Value(std::string("None"))}
    };
 
    std::vector< std::reference_wrapper<XMLObject> > participantRef;
    std::vector< std::reference_wrapper<tCorrelationKey> > correlationKey;
    Attribute& initiatingParticipantRef; ///< Attribute value can be expected to be of type 'std::string'
    std::optional< std::reference_wrapper<Attribute> > loopType; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tChoreographyActivity_H
#ifndef XML_bpmn_choreographyActivity_H
#define XML_bpmn_choreographyActivity_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  choreographyActivity
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - participantRef : QName [2..*] (from: tChoreographyActivity)
 * - correlationKey : tCorrelationKey [0..*] (from: tChoreographyActivity)
 * - initiatingParticipantRef : QName [1..1] (from: tChoreographyActivity)
 * - loopType : tChoreographyLoopType [0..1] (from: tChoreographyActivity)
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class choreographyActivity : public tChoreographyActivity {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:choreographyActivity"] = &createInstance<choreographyActivity>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    choreographyActivity(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "loopType", .value = Value(std::string("None"))}
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_choreographyActivity_H
#ifndef XML_bpmn_tCallChoreography_H
#define XML_bpmn_tCallChoreography_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tParticipantAssociation;
 
/**
 * Overview:
 * - Element name:  tCallChoreography
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - participantAssociation : tParticipantAssociation [0..*]
 * - calledChoreographyRef : QName [0..1]
 * - participantRef : QName [2..*] (from: tChoreographyActivity)
 * - correlationKey : tCorrelationKey [0..*] (from: tChoreographyActivity)
 * - initiatingParticipantRef : QName [1..1] (from: tChoreographyActivity)
 * - loopType : tChoreographyLoopType [0..1] (from: tChoreographyActivity)
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tCallChoreography : public tChoreographyActivity {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tCallChoreography"] = &createInstance<tCallChoreography>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tCallChoreography(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "loopType", .value = Value(std::string("None"))}
    };
 
    std::vector< std::reference_wrapper<tParticipantAssociation> > participantAssociation;
    std::optional< std::reference_wrapper<Attribute> > calledChoreographyRef; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tCallChoreography_H
#ifndef XML_bpmn_callChoreography_H
#define XML_bpmn_callChoreography_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  callChoreography
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - participantAssociation : tParticipantAssociation [0..*] (from: tCallChoreography)
 * - calledChoreographyRef : QName [0..1] (from: tCallChoreography)
 * - participantRef : QName [2..*] (from: tChoreographyActivity)
 * - correlationKey : tCorrelationKey [0..*] (from: tChoreographyActivity)
 * - initiatingParticipantRef : QName [1..1] (from: tChoreographyActivity)
 * - loopType : tChoreographyLoopType [0..1] (from: tChoreographyActivity)
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class callChoreography : public tCallChoreography {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:callChoreography"] = &createInstance<callChoreography>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    callChoreography(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "loopType", .value = Value(std::string("None"))}
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_callChoreography_H
#ifndef XML_bpmn_tChoreographyTask_H
#define XML_bpmn_tChoreographyTask_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tChoreographyTask
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - messageFlowRef : QName [1..2]
 * - participantRef : QName [2..*] (from: tChoreographyActivity)
 * - correlationKey : tCorrelationKey [0..*] (from: tChoreographyActivity)
 * - initiatingParticipantRef : QName [1..1] (from: tChoreographyActivity)
 * - loopType : tChoreographyLoopType [0..1] (from: tChoreographyActivity)
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tChoreographyTask : public tChoreographyActivity {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tChoreographyTask"] = &createInstance<tChoreographyTask>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tChoreographyTask(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "loopType", .value = Value(std::string("None"))}
    };
 
    std::vector< std::reference_wrapper<XMLObject> > messageFlowRef;
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tChoreographyTask_H
#ifndef XML_bpmn_choreographyTask_H
#define XML_bpmn_choreographyTask_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  choreographyTask
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - messageFlowRef : QName [1..2] (from: tChoreographyTask)
 * - participantRef : QName [2..*] (from: tChoreographyActivity)
 * - correlationKey : tCorrelationKey [0..*] (from: tChoreographyActivity)
 * - initiatingParticipantRef : QName [1..1] (from: tChoreographyActivity)
 * - loopType : tChoreographyLoopType [0..1] (from: tChoreographyActivity)
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class choreographyTask : public tChoreographyTask {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:choreographyTask"] = &createInstance<choreographyTask>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    choreographyTask(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "loopType", .value = Value(std::string("None"))}
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_choreographyTask_H
#ifndef XML_bpmn_tEvent_H
#define XML_bpmn_tEvent_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tProperty;
 
/**
 * Overview:
 * - Element name:  tEvent
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - property : tProperty [0..*]
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tEvent : public tFlowNode {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tEvent"] = &createInstance<tEvent>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tEvent(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::vector< std::reference_wrapper<tProperty> > property;
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tEvent_H
#ifndef XML_bpmn_event_H
#define XML_bpmn_event_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  event
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - property : tProperty [0..*] (from: tEvent)
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class event : public tEvent {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:event"] = &createInstance<event>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    event(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_event_H
#ifndef XML_bpmn_tCatchEvent_H
#define XML_bpmn_tCatchEvent_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tDataOutput;
class tDataOutputAssociation;
class tOutputSet;
class tEventDefinition;
 
/**
 * Overview:
 * - Element name:  tCatchEvent
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - dataOutput : tDataOutput [0..*]
 * - dataOutputAssociation : tDataOutputAssociation [0..*]
 * - outputSet : tOutputSet [0..1]
 * - eventDefinition : tEventDefinition [0..*]
 * - eventDefinitionRef : QName [0..*]
 * - parallelMultiple : boolean [0..1]
 * - property : tProperty [0..*] (from: tEvent)
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tCatchEvent : public tEvent {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tCatchEvent"] = &createInstance<tCatchEvent>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tCatchEvent(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "parallelMultiple", .value = Value(std::string("false"))}
    };
 
    std::vector< std::reference_wrapper<tDataOutput> > dataOutput;
    std::vector< std::reference_wrapper<tDataOutputAssociation> > dataOutputAssociation;
    std::optional< std::reference_wrapper<tOutputSet> > outputSet;
    std::vector< std::reference_wrapper<tEventDefinition> > eventDefinition;
    std::vector< std::reference_wrapper<XMLObject> > eventDefinitionRef;
    std::optional< std::reference_wrapper<Attribute> > parallelMultiple; ///< Attribute value can be expected to be of type 'bool'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tCatchEvent_H
#ifndef XML_bpmn_catchEvent_H
#define XML_bpmn_catchEvent_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  catchEvent
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - dataOutput : tDataOutput [0..*] (from: tCatchEvent)
 * - dataOutputAssociation : tDataOutputAssociation [0..*] (from: tCatchEvent)
 * - outputSet : tOutputSet [0..1] (from: tCatchEvent)
 * - eventDefinition : tEventDefinition [0..*] (from: tCatchEvent)
 * - eventDefinitionRef : QName [0..*] (from: tCatchEvent)
 * - parallelMultiple : boolean [0..1] (from: tCatchEvent)
 * - property : tProperty [0..*] (from: tEvent)
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class catchEvent : public tCatchEvent {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:catchEvent"] = &createInstance<catchEvent>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    catchEvent(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "parallelMultiple", .value = Value(std::string("false"))}
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_catchEvent_H
#ifndef XML_bpmn_tBoundaryEvent_H
#define XML_bpmn_tBoundaryEvent_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tBoundaryEvent
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - cancelActivity : boolean [0..1]
 * - attachedToRef : QName [1..1]
 * - dataOutput : tDataOutput [0..*] (from: tCatchEvent)
 * - dataOutputAssociation : tDataOutputAssociation [0..*] (from: tCatchEvent)
 * - outputSet : tOutputSet [0..1] (from: tCatchEvent)
 * - eventDefinition : tEventDefinition [0..*] (from: tCatchEvent)
 * - eventDefinitionRef : QName [0..*] (from: tCatchEvent)
 * - parallelMultiple : boolean [0..1] (from: tCatchEvent)
 * - property : tProperty [0..*] (from: tEvent)
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tBoundaryEvent : public tCatchEvent {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tBoundaryEvent"] = &createInstance<tBoundaryEvent>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tBoundaryEvent(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "cancelActivity", .value = Value(std::string("true"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "parallelMultiple", .value = Value(std::string("false"))}
    };
 
    std::optional< std::reference_wrapper<Attribute> > cancelActivity; ///< Attribute value can be expected to be of type 'bool'
    Attribute& attachedToRef; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tBoundaryEvent_H
#ifndef XML_bpmn_boundaryEvent_H
#define XML_bpmn_boundaryEvent_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  boundaryEvent
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - cancelActivity : boolean [0..1] (from: tBoundaryEvent)
 * - attachedToRef : QName [1..1] (from: tBoundaryEvent)
 * - dataOutput : tDataOutput [0..*] (from: tCatchEvent)
 * - dataOutputAssociation : tDataOutputAssociation [0..*] (from: tCatchEvent)
 * - outputSet : tOutputSet [0..1] (from: tCatchEvent)
 * - eventDefinition : tEventDefinition [0..*] (from: tCatchEvent)
 * - eventDefinitionRef : QName [0..*] (from: tCatchEvent)
 * - parallelMultiple : boolean [0..1] (from: tCatchEvent)
 * - property : tProperty [0..*] (from: tEvent)
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class boundaryEvent : public tBoundaryEvent {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:boundaryEvent"] = &createInstance<boundaryEvent>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    boundaryEvent(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "cancelActivity", .value = Value(std::string("true"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "parallelMultiple", .value = Value(std::string("false"))}
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_boundaryEvent_H
#ifndef XML_bpmn_tFormalExpression_H
#define XML_bpmn_tFormalExpression_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tFormalExpression
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - language : anyURI [0..1]
 * - evaluatesToTypeRef : QName [0..1]
 * - documentation : tDocumentation [0..*] (from: tBaseElementWithMixedContent)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElementWithMixedContent)
 * - id : ID [0..1] (from: tBaseElementWithMixedContent)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tFormalExpression : public tExpression {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tFormalExpression"] = &createInstance<tFormalExpression>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tFormalExpression(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
    friend class tComplexBehaviorDefinition;
    friend class tCorrelationPropertyBinding;
    friend class tCorrelationPropertyRetrievalExpression;
    friend class tDataAssociation;
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::optional< std::reference_wrapper<Attribute> > language; ///< Attribute value can be expected to be of type 'std::string'
    std::optional< std::reference_wrapper<Attribute> > evaluatesToTypeRef; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tFormalExpression_H
#ifndef XML_bpmn_formalExpression_H
#define XML_bpmn_formalExpression_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  formalExpression
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - language : anyURI [0..1] (from: tFormalExpression)
 * - evaluatesToTypeRef : QName [0..1] (from: tFormalExpression)
 * - documentation : tDocumentation [0..*] (from: tBaseElementWithMixedContent)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElementWithMixedContent)
 * - id : ID [0..1] (from: tBaseElementWithMixedContent)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class formalExpression : public tFormalExpression {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:formalExpression"] = &createInstance<formalExpression>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    formalExpression(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_formalExpression_H
#ifndef XML_bpmn_tGateway_H
#define XML_bpmn_tGateway_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tGatewayDirection;
 
/**
 * Overview:
 * - Element name:  tGateway
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - gatewayDirection : tGatewayDirection [0..1]
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tGateway : public tFlowNode {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tGateway"] = &createInstance<tGateway>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tGateway(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "gatewayDirection", .value = Value(std::string("Unspecified"))}
    };
 
    std::optional< std::reference_wrapper<Attribute> > gatewayDirection; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tGateway_H
#ifndef XML_bpmn_gateway_H
#define XML_bpmn_gateway_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  gateway
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - gatewayDirection : tGatewayDirection [0..1] (from: tGateway)
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class gateway : public tGateway {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:gateway"] = &createInstance<gateway>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    gateway(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "gatewayDirection", .value = Value(std::string("Unspecified"))}
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_gateway_H
#ifndef XML_bpmn_tComplexGateway_H
#define XML_bpmn_tComplexGateway_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tExpression;
 
/**
 * Overview:
 * - Element name:  tComplexGateway
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - activationCondition : tExpression [0..1]
 * - default : IDREF [0..1]
 * - gatewayDirection : tGatewayDirection [0..1] (from: tGateway)
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tComplexGateway : public tGateway {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tComplexGateway"] = &createInstance<tComplexGateway>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tComplexGateway(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "gatewayDirection", .value = Value(std::string("Unspecified"))}
    };
 
    std::optional< std::reference_wrapper<tExpression> > activationCondition;
    std::optional< std::reference_wrapper<Attribute> > default_; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tComplexGateway_H
#ifndef XML_bpmn_complexGateway_H
#define XML_bpmn_complexGateway_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  complexGateway
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - activationCondition : tExpression [0..1] (from: tComplexGateway)
 * - default : IDREF [0..1] (from: tComplexGateway)
 * - gatewayDirection : tGatewayDirection [0..1] (from: tGateway)
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class complexGateway : public tComplexGateway {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:complexGateway"] = &createInstance<complexGateway>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    complexGateway(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "gatewayDirection", .value = Value(std::string("Unspecified"))}
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_complexGateway_H
#ifndef XML_bpmn_tEventBasedGateway_H
#define XML_bpmn_tEventBasedGateway_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tEventBasedGatewayType;
 
/**
 * Overview:
 * - Element name:  tEventBasedGateway
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - instantiate : boolean [0..1]
 * - eventGatewayType : tEventBasedGatewayType [0..1]
 * - gatewayDirection : tGatewayDirection [0..1] (from: tGateway)
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tEventBasedGateway : public tGateway {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tEventBasedGateway"] = &createInstance<tEventBasedGateway>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tEventBasedGateway(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "instantiate", .value = Value(std::string("false"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "eventGatewayType", .value = Value(std::string("Exclusive"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "gatewayDirection", .value = Value(std::string("Unspecified"))}
    };
 
    std::optional< std::reference_wrapper<Attribute> > instantiate; ///< Attribute value can be expected to be of type 'bool'
    std::optional< std::reference_wrapper<Attribute> > eventGatewayType; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tEventBasedGateway_H
#ifndef XML_bpmn_eventBasedGateway_H
#define XML_bpmn_eventBasedGateway_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  eventBasedGateway
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - instantiate : boolean [0..1] (from: tEventBasedGateway)
 * - eventGatewayType : tEventBasedGatewayType [0..1] (from: tEventBasedGateway)
 * - gatewayDirection : tGatewayDirection [0..1] (from: tGateway)
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class eventBasedGateway : public tEventBasedGateway {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:eventBasedGateway"] = &createInstance<eventBasedGateway>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    eventBasedGateway(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "instantiate", .value = Value(std::string("false"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "eventGatewayType", .value = Value(std::string("Exclusive"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "gatewayDirection", .value = Value(std::string("Unspecified"))}
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_eventBasedGateway_H
#ifndef XML_bpmn_tExclusiveGateway_H
#define XML_bpmn_tExclusiveGateway_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tExclusiveGateway
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - default : IDREF [0..1]
 * - gatewayDirection : tGatewayDirection [0..1] (from: tGateway)
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tExclusiveGateway : public tGateway {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tExclusiveGateway"] = &createInstance<tExclusiveGateway>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tExclusiveGateway(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "gatewayDirection", .value = Value(std::string("Unspecified"))}
    };
 
    std::optional< std::reference_wrapper<Attribute> > default_; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tExclusiveGateway_H
#ifndef XML_bpmn_exclusiveGateway_H
#define XML_bpmn_exclusiveGateway_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  exclusiveGateway
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - default : IDREF [0..1] (from: tExclusiveGateway)
 * - gatewayDirection : tGatewayDirection [0..1] (from: tGateway)
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class exclusiveGateway : public tExclusiveGateway {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:exclusiveGateway"] = &createInstance<exclusiveGateway>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    exclusiveGateway(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "gatewayDirection", .value = Value(std::string("Unspecified"))}
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_exclusiveGateway_H
#ifndef XML_bpmn_tGroup_H
#define XML_bpmn_tGroup_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tGroup
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - categoryValueRef : QName [0..1]
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tGroup : public tArtifact {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tGroup"] = &createInstance<tGroup>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tGroup(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::optional< std::reference_wrapper<Attribute> > categoryValueRef; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tGroup_H
#ifndef XML_bpmn_group_H
#define XML_bpmn_group_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  group
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - categoryValueRef : QName [0..1] (from: tGroup)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class group : public tGroup {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:group"] = &createInstance<group>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    group(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_group_H
#ifndef XML_bpmn_tImport_H
#define XML_bpmn_tImport_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tImport
 * - XML-Schema:    xsd/BPMN20.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - namespace : anyURI [1..1]
 * - location : string [1..1]
 * - importType : anyURI [1..1]
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tImport : public XMLObject {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tImport"] = &createInstance<tImport>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tImport(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
    friend class tDefinitions;
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    Attribute& namespace_; ///< Attribute value can be expected to be of type 'std::string'
    Attribute& location; ///< Attribute value can be expected to be of type 'std::string'
    Attribute& importType; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tImport_H
#ifndef XML_bpmn_import_H
#define XML_bpmn_import_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  import
 * - XML-Schema:    xsd/BPMN20.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - namespace : anyURI [1..1] (from: tImport)
 * - location : string [1..1] (from: tImport)
 * - importType : anyURI [1..1] (from: tImport)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class import : public tImport {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:import"] = &createInstance<import>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    import(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_import_H
#ifndef XML_bpmn_tInclusiveGateway_H
#define XML_bpmn_tInclusiveGateway_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tInclusiveGateway
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - default : IDREF [0..1]
 * - gatewayDirection : tGatewayDirection [0..1] (from: tGateway)
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tInclusiveGateway : public tGateway {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tInclusiveGateway"] = &createInstance<tInclusiveGateway>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tInclusiveGateway(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "gatewayDirection", .value = Value(std::string("Unspecified"))}
    };
 
    std::optional< std::reference_wrapper<Attribute> > default_; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tInclusiveGateway_H
#ifndef XML_bpmn_inclusiveGateway_H
#define XML_bpmn_inclusiveGateway_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  inclusiveGateway
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - default : IDREF [0..1] (from: tInclusiveGateway)
 * - gatewayDirection : tGatewayDirection [0..1] (from: tGateway)
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class inclusiveGateway : public tInclusiveGateway {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:inclusiveGateway"] = &createInstance<inclusiveGateway>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    inclusiveGateway(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "gatewayDirection", .value = Value(std::string("Unspecified"))}
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_inclusiveGateway_H
#ifndef XML_bpmn_tInputOutputBinding_H
#define XML_bpmn_tInputOutputBinding_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tInputOutputBinding
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - operationRef : QName [1..1]
 * - inputDataRef : IDREF [1..1]
 * - outputDataRef : IDREF [1..1]
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tInputOutputBinding : public tBaseElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tInputOutputBinding"] = &createInstance<tInputOutputBinding>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tInputOutputBinding(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
    friend class tCallableElement;
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    Attribute& operationRef; ///< Attribute value can be expected to be of type 'std::string'
    Attribute& inputDataRef; ///< Attribute value can be expected to be of type 'std::string'
    Attribute& outputDataRef; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tInputOutputBinding_H
#ifndef XML_bpmn_ioBinding_H
#define XML_bpmn_ioBinding_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  ioBinding
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - operationRef : QName [1..1] (from: tInputOutputBinding)
 * - inputDataRef : IDREF [1..1] (from: tInputOutputBinding)
 * - outputDataRef : IDREF [1..1] (from: tInputOutputBinding)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class ioBinding : public tInputOutputBinding {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:ioBinding"] = &createInstance<ioBinding>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    ioBinding(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_ioBinding_H
#ifndef XML_bpmn_tInputOutputSpecification_H
#define XML_bpmn_tInputOutputSpecification_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tDataInput;
class tDataOutput;
class tInputSet;
class tOutputSet;
 
/**
 * Overview:
 * - Element name:  tInputOutputSpecification
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - dataInput : tDataInput [0..*]
 * - dataOutput : tDataOutput [0..*]
 * - inputSet : tInputSet [1..*]
 * - outputSet : tOutputSet [1..*]
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tInputOutputSpecification : public tBaseElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tInputOutputSpecification"] = &createInstance<tInputOutputSpecification>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tInputOutputSpecification(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
    friend class tActivity;
    friend class tCallableElement;
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::vector< std::reference_wrapper<tDataInput> > dataInput;
    std::vector< std::reference_wrapper<tDataOutput> > dataOutput;
    std::vector< std::reference_wrapper<tInputSet> > inputSet;
    std::vector< std::reference_wrapper<tOutputSet> > outputSet;
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tInputOutputSpecification_H
#ifndef XML_bpmn_ioSpecification_H
#define XML_bpmn_ioSpecification_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  ioSpecification
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - dataInput : tDataInput [0..*] (from: tInputOutputSpecification)
 * - dataOutput : tDataOutput [0..*] (from: tInputOutputSpecification)
 * - inputSet : tInputSet [1..*] (from: tInputOutputSpecification)
 * - outputSet : tOutputSet [1..*] (from: tInputOutputSpecification)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class ioSpecification : public tInputOutputSpecification {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:ioSpecification"] = &createInstance<ioSpecification>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    ioSpecification(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_ioSpecification_H
#ifndef XML_bpmn_tInputSet_H
#define XML_bpmn_tInputSet_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tInputSet
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - dataInputRefs : IDREF [0..*]
 * - optionalInputRefs : IDREF [0..*]
 * - whileExecutingInputRefs : IDREF [0..*]
 * - outputSetRefs : IDREF [0..*]
 * - name : string [0..1]
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tInputSet : public tBaseElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tInputSet"] = &createInstance<tInputSet>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tInputSet(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
    friend class tInputOutputSpecification;
    friend class tThrowEvent;
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::vector< std::reference_wrapper<XMLObject> > dataInputRefs;
    std::vector< std::reference_wrapper<XMLObject> > optionalInputRefs;
    std::vector< std::reference_wrapper<XMLObject> > whileExecutingInputRefs;
    std::vector< std::reference_wrapper<XMLObject> > outputSetRefs;
    std::optional< std::reference_wrapper<Attribute> > name; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tInputSet_H
#ifndef XML_bpmn_inputSet_H
#define XML_bpmn_inputSet_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  inputSet
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - dataInputRefs : IDREF [0..*] (from: tInputSet)
 * - optionalInputRefs : IDREF [0..*] (from: tInputSet)
 * - whileExecutingInputRefs : IDREF [0..*] (from: tInputSet)
 * - outputSetRefs : IDREF [0..*] (from: tInputSet)
 * - name : string [0..1] (from: tInputSet)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class inputSet : public tInputSet {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:inputSet"] = &createInstance<inputSet>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    inputSet(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_inputSet_H
#ifndef XML_bpmn_tIntermediateCatchEvent_H
#define XML_bpmn_tIntermediateCatchEvent_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tIntermediateCatchEvent
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - dataOutput : tDataOutput [0..*] (from: tCatchEvent)
 * - dataOutputAssociation : tDataOutputAssociation [0..*] (from: tCatchEvent)
 * - outputSet : tOutputSet [0..1] (from: tCatchEvent)
 * - eventDefinition : tEventDefinition [0..*] (from: tCatchEvent)
 * - eventDefinitionRef : QName [0..*] (from: tCatchEvent)
 * - parallelMultiple : boolean [0..1] (from: tCatchEvent)
 * - property : tProperty [0..*] (from: tEvent)
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tIntermediateCatchEvent : public tCatchEvent {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tIntermediateCatchEvent"] = &createInstance<tIntermediateCatchEvent>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tIntermediateCatchEvent(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "parallelMultiple", .value = Value(std::string("false"))}
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tIntermediateCatchEvent_H
#ifndef XML_bpmn_intermediateCatchEvent_H
#define XML_bpmn_intermediateCatchEvent_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  intermediateCatchEvent
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - dataOutput : tDataOutput [0..*] (from: tCatchEvent)
 * - dataOutputAssociation : tDataOutputAssociation [0..*] (from: tCatchEvent)
 * - outputSet : tOutputSet [0..1] (from: tCatchEvent)
 * - eventDefinition : tEventDefinition [0..*] (from: tCatchEvent)
 * - eventDefinitionRef : QName [0..*] (from: tCatchEvent)
 * - parallelMultiple : boolean [0..1] (from: tCatchEvent)
 * - property : tProperty [0..*] (from: tEvent)
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class intermediateCatchEvent : public tIntermediateCatchEvent {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:intermediateCatchEvent"] = &createInstance<intermediateCatchEvent>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    intermediateCatchEvent(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "parallelMultiple", .value = Value(std::string("false"))}
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_intermediateCatchEvent_H
#ifndef XML_bpmn_tLane_H
#define XML_bpmn_tLane_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tBaseElement;
class tLaneSet;
 
/**
 * Overview:
 * - Element name:  tLane
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - partitionElement : tBaseElement [0..1]
 * - flowNodeRef : IDREF [0..*]
 * - childLaneSet : tLaneSet [0..1]
 * - name : string [0..1]
 * - partitionElementRef : QName [0..1]
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tLane : public tBaseElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tLane"] = &createInstance<tLane>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tLane(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
    friend class tLaneSet;
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::optional< std::reference_wrapper<tBaseElement> > partitionElement;
    std::vector< std::reference_wrapper<XMLObject> > flowNodeRef;
    std::optional< std::reference_wrapper<tLaneSet> > childLaneSet;
    std::optional< std::reference_wrapper<Attribute> > name; ///< Attribute value can be expected to be of type 'std::string'
    std::optional< std::reference_wrapper<Attribute> > partitionElementRef; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tLane_H
#ifndef XML_bpmn_lane_H
#define XML_bpmn_lane_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  lane
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - partitionElement : tBaseElement [0..1] (from: tLane)
 * - flowNodeRef : IDREF [0..*] (from: tLane)
 * - childLaneSet : tLaneSet [0..1] (from: tLane)
 * - name : string [0..1] (from: tLane)
 * - partitionElementRef : QName [0..1] (from: tLane)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class lane : public tLane {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:lane"] = &createInstance<lane>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    lane(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_lane_H
#ifndef XML_bpmn_tLaneSet_H
#define XML_bpmn_tLaneSet_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tLane;
 
/**
 * Overview:
 * - Element name:  tLaneSet
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - lane : tLane [0..*]
 * - name : string [0..1]
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tLaneSet : public tBaseElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tLaneSet"] = &createInstance<tLaneSet>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tLaneSet(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
    friend class tLane;
    friend class tProcess;
    friend class tSubProcess;
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::vector< std::reference_wrapper<tLane> > lane;
    std::optional< std::reference_wrapper<Attribute> > name; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tLaneSet_H
#ifndef XML_bpmn_laneSet_H
#define XML_bpmn_laneSet_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  laneSet
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - lane : tLane [0..*] (from: tLaneSet)
 * - name : string [0..1] (from: tLaneSet)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class laneSet : public tLaneSet {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:laneSet"] = &createInstance<laneSet>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    laneSet(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_laneSet_H
#ifndef XML_bpmn_tLoopCharacteristics_H
#define XML_bpmn_tLoopCharacteristics_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tLoopCharacteristics
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tLoopCharacteristics : public tBaseElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tLoopCharacteristics"] = &createInstance<tLoopCharacteristics>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tLoopCharacteristics(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
    friend class tActivity;
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tLoopCharacteristics_H
#ifndef XML_bpmn_loopCharacteristics_H
#define XML_bpmn_loopCharacteristics_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  loopCharacteristics
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class loopCharacteristics : public tLoopCharacteristics {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:loopCharacteristics"] = &createInstance<loopCharacteristics>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    loopCharacteristics(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_loopCharacteristics_H
#ifndef XML_bpmn_tMessageFlow_H
#define XML_bpmn_tMessageFlow_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tMessageFlow
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - name : string [0..1]
 * - sourceRef : QName [1..1]
 * - targetRef : QName [1..1]
 * - messageRef : QName [0..1]
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tMessageFlow : public tBaseElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tMessageFlow"] = &createInstance<tMessageFlow>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tMessageFlow(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
    friend class tCollaboration;
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::optional< std::reference_wrapper<Attribute> > name; ///< Attribute value can be expected to be of type 'std::string'
    Attribute& sourceRef; ///< Attribute value can be expected to be of type 'std::string'
    Attribute& targetRef; ///< Attribute value can be expected to be of type 'std::string'
    std::optional< std::reference_wrapper<Attribute> > messageRef; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tMessageFlow_H
#ifndef XML_bpmn_messageFlow_H
#define XML_bpmn_messageFlow_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  messageFlow
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - name : string [0..1] (from: tMessageFlow)
 * - sourceRef : QName [1..1] (from: tMessageFlow)
 * - targetRef : QName [1..1] (from: tMessageFlow)
 * - messageRef : QName [0..1] (from: tMessageFlow)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class messageFlow : public tMessageFlow {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:messageFlow"] = &createInstance<messageFlow>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    messageFlow(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_messageFlow_H
#ifndef XML_bpmn_tMessageFlowAssociation_H
#define XML_bpmn_tMessageFlowAssociation_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tMessageFlowAssociation
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - innerMessageFlowRef : QName [1..1]
 * - outerMessageFlowRef : QName [1..1]
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tMessageFlowAssociation : public tBaseElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tMessageFlowAssociation"] = &createInstance<tMessageFlowAssociation>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tMessageFlowAssociation(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
    friend class tCollaboration;
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    Attribute& innerMessageFlowRef; ///< Attribute value can be expected to be of type 'std::string'
    Attribute& outerMessageFlowRef; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tMessageFlowAssociation_H
#ifndef XML_bpmn_messageFlowAssociation_H
#define XML_bpmn_messageFlowAssociation_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  messageFlowAssociation
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - innerMessageFlowRef : QName [1..1] (from: tMessageFlowAssociation)
 * - outerMessageFlowRef : QName [1..1] (from: tMessageFlowAssociation)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class messageFlowAssociation : public tMessageFlowAssociation {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:messageFlowAssociation"] = &createInstance<messageFlowAssociation>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    messageFlowAssociation(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_messageFlowAssociation_H
#ifndef XML_bpmn_tMonitoring_H
#define XML_bpmn_tMonitoring_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tMonitoring
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tMonitoring : public tBaseElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tMonitoring"] = &createInstance<tMonitoring>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tMonitoring(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
    friend class tFlowElement;
    friend class tProcess;
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tMonitoring_H
#ifndef XML_bpmn_monitoring_H
#define XML_bpmn_monitoring_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  monitoring
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class monitoring : public tMonitoring {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:monitoring"] = &createInstance<monitoring>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    monitoring(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_monitoring_H
#ifndef XML_bpmn_tMultiInstanceLoopCharacteristics_H
#define XML_bpmn_tMultiInstanceLoopCharacteristics_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tExpression;
class tDataInput;
class tDataOutput;
class tComplexBehaviorDefinition;
class tExpression;
class tMultiInstanceFlowCondition;
 
/**
 * Overview:
 * - Element name:  tMultiInstanceLoopCharacteristics
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - loopCardinality : tExpression [0..1]
 * - loopDataInputRef : QName [0..1]
 * - loopDataOutputRef : QName [0..1]
 * - inputDataItem : tDataInput [0..1]
 * - outputDataItem : tDataOutput [0..1]
 * - complexBehaviorDefinition : tComplexBehaviorDefinition [0..*]
 * - completionCondition : tExpression [0..1]
 * - isSequential : boolean [0..1]
 * - behavior : tMultiInstanceFlowCondition [0..1]
 * - oneBehaviorEventRef : QName [0..1]
 * - noneBehaviorEventRef : QName [0..1]
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tMultiInstanceLoopCharacteristics : public tLoopCharacteristics {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tMultiInstanceLoopCharacteristics"] = &createInstance<tMultiInstanceLoopCharacteristics>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tMultiInstanceLoopCharacteristics(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "isSequential", .value = Value(std::string("false"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "behavior", .value = Value(std::string("All"))}
    };
 
    std::optional< std::reference_wrapper<tExpression> > loopCardinality;
    std::optional< std::reference_wrapper<XMLObject> > loopDataInputRef;
    std::optional< std::reference_wrapper<XMLObject> > loopDataOutputRef;
    std::optional< std::reference_wrapper<tDataInput> > inputDataItem;
    std::optional< std::reference_wrapper<tDataOutput> > outputDataItem;
    std::vector< std::reference_wrapper<tComplexBehaviorDefinition> > complexBehaviorDefinition;
    std::optional< std::reference_wrapper<tExpression> > completionCondition;
    std::optional< std::reference_wrapper<Attribute> > isSequential; ///< Attribute value can be expected to be of type 'bool'
    std::optional< std::reference_wrapper<Attribute> > behavior; ///< Attribute value can be expected to be of type 'std::string'
    std::optional< std::reference_wrapper<Attribute> > oneBehaviorEventRef; ///< Attribute value can be expected to be of type 'std::string'
    std::optional< std::reference_wrapper<Attribute> > noneBehaviorEventRef; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tMultiInstanceLoopCharacteristics_H
#ifndef XML_bpmn_multiInstanceLoopCharacteristics_H
#define XML_bpmn_multiInstanceLoopCharacteristics_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  multiInstanceLoopCharacteristics
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - loopCardinality : tExpression [0..1] (from: tMultiInstanceLoopCharacteristics)
 * - loopDataInputRef : QName [0..1] (from: tMultiInstanceLoopCharacteristics)
 * - loopDataOutputRef : QName [0..1] (from: tMultiInstanceLoopCharacteristics)
 * - inputDataItem : tDataInput [0..1] (from: tMultiInstanceLoopCharacteristics)
 * - outputDataItem : tDataOutput [0..1] (from: tMultiInstanceLoopCharacteristics)
 * - complexBehaviorDefinition : tComplexBehaviorDefinition [0..*] (from: tMultiInstanceLoopCharacteristics)
 * - completionCondition : tExpression [0..1] (from: tMultiInstanceLoopCharacteristics)
 * - isSequential : boolean [0..1] (from: tMultiInstanceLoopCharacteristics)
 * - behavior : tMultiInstanceFlowCondition [0..1] (from: tMultiInstanceLoopCharacteristics)
 * - oneBehaviorEventRef : QName [0..1] (from: tMultiInstanceLoopCharacteristics)
 * - noneBehaviorEventRef : QName [0..1] (from: tMultiInstanceLoopCharacteristics)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class multiInstanceLoopCharacteristics : public tMultiInstanceLoopCharacteristics {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:multiInstanceLoopCharacteristics"] = &createInstance<multiInstanceLoopCharacteristics>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    multiInstanceLoopCharacteristics(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "isSequential", .value = Value(std::string("false"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "behavior", .value = Value(std::string("All"))}
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_multiInstanceLoopCharacteristics_H
#ifndef XML_bpmn_tOperation_H
#define XML_bpmn_tOperation_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tOperation
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - inMessageRef : QName [1..1]
 * - outMessageRef : QName [0..1]
 * - errorRef : QName [0..*]
 * - name : string [1..1]
 * - implementationRef : QName [0..1]
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tOperation : public tBaseElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tOperation"] = &createInstance<tOperation>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tOperation(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
    friend class tInterface;
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    XMLObject& inMessageRef;
    std::optional< std::reference_wrapper<XMLObject> > outMessageRef;
    std::vector< std::reference_wrapper<XMLObject> > errorRef;
    Attribute& name; ///< Attribute value can be expected to be of type 'std::string'
    std::optional< std::reference_wrapper<Attribute> > implementationRef; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tOperation_H
#ifndef XML_bpmn_operation_H
#define XML_bpmn_operation_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  operation
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - inMessageRef : QName [1..1] (from: tOperation)
 * - outMessageRef : QName [0..1] (from: tOperation)
 * - errorRef : QName [0..*] (from: tOperation)
 * - name : string [1..1] (from: tOperation)
 * - implementationRef : QName [0..1] (from: tOperation)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class operation : public tOperation {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:operation"] = &createInstance<operation>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    operation(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_operation_H
#ifndef XML_bpmn_tOutputSet_H
#define XML_bpmn_tOutputSet_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tOutputSet
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - dataOutputRefs : IDREF [0..*]
 * - optionalOutputRefs : IDREF [0..*]
 * - whileExecutingOutputRefs : IDREF [0..*]
 * - inputSetRefs : IDREF [0..*]
 * - name : string [0..1]
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tOutputSet : public tBaseElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tOutputSet"] = &createInstance<tOutputSet>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tOutputSet(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
    friend class tCatchEvent;
    friend class tInputOutputSpecification;
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::vector< std::reference_wrapper<XMLObject> > dataOutputRefs;
    std::vector< std::reference_wrapper<XMLObject> > optionalOutputRefs;
    std::vector< std::reference_wrapper<XMLObject> > whileExecutingOutputRefs;
    std::vector< std::reference_wrapper<XMLObject> > inputSetRefs;
    std::optional< std::reference_wrapper<Attribute> > name; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tOutputSet_H
#ifndef XML_bpmn_outputSet_H
#define XML_bpmn_outputSet_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  outputSet
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - dataOutputRefs : IDREF [0..*] (from: tOutputSet)
 * - optionalOutputRefs : IDREF [0..*] (from: tOutputSet)
 * - whileExecutingOutputRefs : IDREF [0..*] (from: tOutputSet)
 * - inputSetRefs : IDREF [0..*] (from: tOutputSet)
 * - name : string [0..1] (from: tOutputSet)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class outputSet : public tOutputSet {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:outputSet"] = &createInstance<outputSet>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    outputSet(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_outputSet_H
#ifndef XML_bpmn_tParallelGateway_H
#define XML_bpmn_tParallelGateway_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tParallelGateway
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - gatewayDirection : tGatewayDirection [0..1] (from: tGateway)
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tParallelGateway : public tGateway {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tParallelGateway"] = &createInstance<tParallelGateway>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tParallelGateway(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "gatewayDirection", .value = Value(std::string("Unspecified"))}
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tParallelGateway_H
#ifndef XML_bpmn_parallelGateway_H
#define XML_bpmn_parallelGateway_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  parallelGateway
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - gatewayDirection : tGatewayDirection [0..1] (from: tGateway)
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class parallelGateway : public tParallelGateway {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:parallelGateway"] = &createInstance<parallelGateway>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    parallelGateway(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "gatewayDirection", .value = Value(std::string("Unspecified"))}
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_parallelGateway_H
#ifndef XML_bpmn_tParticipant_H
#define XML_bpmn_tParticipant_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tParticipantMultiplicity;
 
/**
 * Overview:
 * - Element name:  tParticipant
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - interfaceRef : QName [0..*]
 * - endPointRef : QName [0..*]
 * - participantMultiplicity : tParticipantMultiplicity [0..1]
 * - name : string [0..1]
 * - processRef : QName [0..1]
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tParticipant : public tBaseElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tParticipant"] = &createInstance<tParticipant>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tParticipant(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
    friend class tCollaboration;
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::vector< std::reference_wrapper<XMLObject> > interfaceRef;
    std::vector< std::reference_wrapper<XMLObject> > endPointRef;
    std::optional< std::reference_wrapper<tParticipantMultiplicity> > participantMultiplicity;
    std::optional< std::reference_wrapper<Attribute> > name; ///< Attribute value can be expected to be of type 'std::string'
    std::optional< std::reference_wrapper<Attribute> > processRef; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tParticipant_H
#ifndef XML_bpmn_participant_H
#define XML_bpmn_participant_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  participant
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - interfaceRef : QName [0..*] (from: tParticipant)
 * - endPointRef : QName [0..*] (from: tParticipant)
 * - participantMultiplicity : tParticipantMultiplicity [0..1] (from: tParticipant)
 * - name : string [0..1] (from: tParticipant)
 * - processRef : QName [0..1] (from: tParticipant)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class participant : public tParticipant {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:participant"] = &createInstance<participant>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    participant(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_participant_H
#ifndef XML_bpmn_tParticipantAssociation_H
#define XML_bpmn_tParticipantAssociation_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tParticipantAssociation
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - innerParticipantRef : QName [1..1]
 * - outerParticipantRef : QName [1..1]
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tParticipantAssociation : public tBaseElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tParticipantAssociation"] = &createInstance<tParticipantAssociation>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tParticipantAssociation(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
    friend class tCallChoreography;
    friend class tCallConversation;
    friend class tCollaboration;
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    XMLObject& innerParticipantRef;
    XMLObject& outerParticipantRef;
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tParticipantAssociation_H
#ifndef XML_bpmn_participantAssociation_H
#define XML_bpmn_participantAssociation_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  participantAssociation
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - innerParticipantRef : QName [1..1] (from: tParticipantAssociation)
 * - outerParticipantRef : QName [1..1] (from: tParticipantAssociation)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class participantAssociation : public tParticipantAssociation {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:participantAssociation"] = &createInstance<participantAssociation>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    participantAssociation(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_participantAssociation_H
#ifndef XML_bpmn_tParticipantMultiplicity_H
#define XML_bpmn_tParticipantMultiplicity_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tParticipantMultiplicity
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - minimum : int [0..1]
 * - maximum : int [0..1]
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tParticipantMultiplicity : public tBaseElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tParticipantMultiplicity"] = &createInstance<tParticipantMultiplicity>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tParticipantMultiplicity(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
    friend class tParticipant;
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "minimum", .value = Value(std::string("0"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "maximum", .value = Value(std::string("1"))}
    };
 
    std::optional< std::reference_wrapper<Attribute> > minimum; ///< Attribute value can be expected to be of type 'int'
    std::optional< std::reference_wrapper<Attribute> > maximum; ///< Attribute value can be expected to be of type 'int'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tParticipantMultiplicity_H
#ifndef XML_bpmn_participantMultiplicity_H
#define XML_bpmn_participantMultiplicity_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  participantMultiplicity
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - minimum : int [0..1] (from: tParticipantMultiplicity)
 * - maximum : int [0..1] (from: tParticipantMultiplicity)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class participantMultiplicity : public tParticipantMultiplicity {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:participantMultiplicity"] = &createInstance<participantMultiplicity>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    participantMultiplicity(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "minimum", .value = Value(std::string("0"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "maximum", .value = Value(std::string("1"))}
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_participantMultiplicity_H
#ifndef XML_bpmn_tProperty_H
#define XML_bpmn_tProperty_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tDataState;
 
/**
 * Overview:
 * - Element name:  tProperty
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - dataState : tDataState [0..1]
 * - name : string [0..1]
 * - itemSubjectRef : QName [0..1]
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tProperty : public tBaseElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tProperty"] = &createInstance<tProperty>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tProperty(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
    friend class tActivity;
    friend class tEvent;
    friend class tProcess;
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::optional< std::reference_wrapper<tDataState> > dataState;
    std::optional< std::reference_wrapper<Attribute> > name; ///< Attribute value can be expected to be of type 'std::string'
    std::optional< std::reference_wrapper<Attribute> > itemSubjectRef; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tProperty_H
#ifndef XML_bpmn_property_H
#define XML_bpmn_property_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  property
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - dataState : tDataState [0..1] (from: tProperty)
 * - name : string [0..1] (from: tProperty)
 * - itemSubjectRef : QName [0..1] (from: tProperty)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class property : public tProperty {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:property"] = &createInstance<property>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    property(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_property_H
#ifndef XML_bpmn_tRelationship_H
#define XML_bpmn_tRelationship_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tRelationshipDirection;
 
/**
 * Overview:
 * - Element name:  tRelationship
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - source : QName [1..*]
 * - target : QName [1..*]
 * - type : string [1..1]
 * - direction : tRelationshipDirection [0..1]
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tRelationship : public tBaseElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tRelationship"] = &createInstance<tRelationship>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tRelationship(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
    friend class tDefinitions;
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::vector< std::reference_wrapper<XMLObject> > source;
    std::vector< std::reference_wrapper<XMLObject> > target;
    Attribute& type; ///< Attribute value can be expected to be of type 'std::string'
    std::optional< std::reference_wrapper<Attribute> > direction; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tRelationship_H
#ifndef XML_bpmn_relationship_H
#define XML_bpmn_relationship_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  relationship
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - source : QName [1..*] (from: tRelationship)
 * - target : QName [1..*] (from: tRelationship)
 * - type : string [1..1] (from: tRelationship)
 * - direction : tRelationshipDirection [0..1] (from: tRelationship)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class relationship : public tRelationship {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:relationship"] = &createInstance<relationship>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    relationship(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_relationship_H
#ifndef XML_bpmn_tRendering_H
#define XML_bpmn_tRendering_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tRendering
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tRendering : public tBaseElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tRendering"] = &createInstance<tRendering>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tRendering(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
    friend class tGlobalUserTask;
    friend class tUserTask;
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tRendering_H
#ifndef XML_bpmn_rendering_H
#define XML_bpmn_rendering_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  rendering
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class rendering : public tRendering {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:rendering"] = &createInstance<rendering>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    rendering(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_rendering_H
#ifndef XML_bpmn_tResourceAssignmentExpression_H
#define XML_bpmn_tResourceAssignmentExpression_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tExpression;
 
/**
 * Overview:
 * - Element name:  tResourceAssignmentExpression
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - expression : tExpression [1..1]
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tResourceAssignmentExpression : public tBaseElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tResourceAssignmentExpression"] = &createInstance<tResourceAssignmentExpression>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tResourceAssignmentExpression(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
    friend class tResourceRole;
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    tExpression& expression;
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tResourceAssignmentExpression_H
#ifndef XML_bpmn_resourceAssignmentExpression_H
#define XML_bpmn_resourceAssignmentExpression_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  resourceAssignmentExpression
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - expression : tExpression [1..1] (from: tResourceAssignmentExpression)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class resourceAssignmentExpression : public tResourceAssignmentExpression {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:resourceAssignmentExpression"] = &createInstance<resourceAssignmentExpression>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    resourceAssignmentExpression(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_resourceAssignmentExpression_H
#ifndef XML_bpmn_tResourceParameter_H
#define XML_bpmn_tResourceParameter_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tResourceParameter
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - name : string [0..1]
 * - type : QName [0..1]
 * - isRequired : boolean [0..1]
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tResourceParameter : public tBaseElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tResourceParameter"] = &createInstance<tResourceParameter>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tResourceParameter(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
    friend class tResource;
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::optional< std::reference_wrapper<Attribute> > name; ///< Attribute value can be expected to be of type 'std::string'
    std::optional< std::reference_wrapper<Attribute> > type; ///< Attribute value can be expected to be of type 'std::string'
    std::optional< std::reference_wrapper<Attribute> > isRequired; ///< Attribute value can be expected to be of type 'bool'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tResourceParameter_H
#ifndef XML_bpmn_resourceParameter_H
#define XML_bpmn_resourceParameter_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  resourceParameter
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - name : string [0..1] (from: tResourceParameter)
 * - type : QName [0..1] (from: tResourceParameter)
 * - isRequired : boolean [0..1] (from: tResourceParameter)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class resourceParameter : public tResourceParameter {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:resourceParameter"] = &createInstance<resourceParameter>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    resourceParameter(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_resourceParameter_H
#ifndef XML_bpmn_tResourceParameterBinding_H
#define XML_bpmn_tResourceParameterBinding_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tExpression;
 
/**
 * Overview:
 * - Element name:  tResourceParameterBinding
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - expression : tExpression [1..1]
 * - parameterRef : QName [1..1]
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tResourceParameterBinding : public tBaseElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tResourceParameterBinding"] = &createInstance<tResourceParameterBinding>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tResourceParameterBinding(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
    friend class tResourceRole;
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    tExpression& expression;
    Attribute& parameterRef; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tResourceParameterBinding_H
#ifndef XML_bpmn_resourceParameterBinding_H
#define XML_bpmn_resourceParameterBinding_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  resourceParameterBinding
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - expression : tExpression [1..1] (from: tResourceParameterBinding)
 * - parameterRef : QName [1..1] (from: tResourceParameterBinding)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class resourceParameterBinding : public tResourceParameterBinding {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:resourceParameterBinding"] = &createInstance<resourceParameterBinding>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    resourceParameterBinding(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_resourceParameterBinding_H
#ifndef XML_bpmn_tResourceRole_H
#define XML_bpmn_tResourceRole_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tResourceAssignmentExpression;
class tResourceParameterBinding;
 
/**
 * Overview:
 * - Element name:  tResourceRole
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - resourceAssignmentExpression : tResourceAssignmentExpression [0..1]
 * - resourceRef : QName [0..*]
 * - resourceParameterBinding : tResourceParameterBinding [0..*]
 * - name : string [0..1]
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tResourceRole : public tBaseElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tResourceRole"] = &createInstance<tResourceRole>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tResourceRole(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
    friend class tActivity;
    friend class tGlobalTask;
    friend class tProcess;
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::optional< std::reference_wrapper<tResourceAssignmentExpression> > resourceAssignmentExpression;
    std::vector< std::reference_wrapper<XMLObject> > resourceRef;
    std::vector< std::reference_wrapper<tResourceParameterBinding> > resourceParameterBinding;
    std::optional< std::reference_wrapper<Attribute> > name; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tResourceRole_H
#ifndef XML_bpmn_resourceRole_H
#define XML_bpmn_resourceRole_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  resourceRole
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - resourceAssignmentExpression : tResourceAssignmentExpression [0..1] (from: tResourceRole)
 * - resourceRef : QName [0..*] (from: tResourceRole)
 * - resourceParameterBinding : tResourceParameterBinding [0..*] (from: tResourceRole)
 * - name : string [0..1] (from: tResourceRole)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class resourceRole : public tResourceRole {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:resourceRole"] = &createInstance<resourceRole>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    resourceRole(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_resourceRole_H
#ifndef XML_bpmn_tPerformer_H
#define XML_bpmn_tPerformer_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tPerformer
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - resourceAssignmentExpression : tResourceAssignmentExpression [0..1] (from: tResourceRole)
 * - resourceRef : QName [0..*] (from: tResourceRole)
 * - resourceParameterBinding : tResourceParameterBinding [0..*] (from: tResourceRole)
 * - name : string [0..1] (from: tResourceRole)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tPerformer : public tResourceRole {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tPerformer"] = &createInstance<tPerformer>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tPerformer(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tPerformer_H
#ifndef XML_bpmn_performer_H
#define XML_bpmn_performer_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  performer
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - resourceAssignmentExpression : tResourceAssignmentExpression [0..1] (from: tResourceRole)
 * - resourceRef : QName [0..*] (from: tResourceRole)
 * - resourceParameterBinding : tResourceParameterBinding [0..*] (from: tResourceRole)
 * - name : string [0..1] (from: tResourceRole)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class performer : public tPerformer {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:performer"] = &createInstance<performer>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    performer(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_performer_H
#ifndef XML_bpmn_tHumanPerformer_H
#define XML_bpmn_tHumanPerformer_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tHumanPerformer
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - resourceAssignmentExpression : tResourceAssignmentExpression [0..1] (from: tResourceRole)
 * - resourceRef : QName [0..*] (from: tResourceRole)
 * - resourceParameterBinding : tResourceParameterBinding [0..*] (from: tResourceRole)
 * - name : string [0..1] (from: tResourceRole)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tHumanPerformer : public tPerformer {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tHumanPerformer"] = &createInstance<tHumanPerformer>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tHumanPerformer(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tHumanPerformer_H
#ifndef XML_bpmn_humanPerformer_H
#define XML_bpmn_humanPerformer_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  humanPerformer
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - resourceAssignmentExpression : tResourceAssignmentExpression [0..1] (from: tResourceRole)
 * - resourceRef : QName [0..*] (from: tResourceRole)
 * - resourceParameterBinding : tResourceParameterBinding [0..*] (from: tResourceRole)
 * - name : string [0..1] (from: tResourceRole)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class humanPerformer : public tHumanPerformer {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:humanPerformer"] = &createInstance<humanPerformer>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    humanPerformer(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_humanPerformer_H
#ifndef XML_bpmn_tPotentialOwner_H
#define XML_bpmn_tPotentialOwner_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tPotentialOwner
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - resourceAssignmentExpression : tResourceAssignmentExpression [0..1] (from: tResourceRole)
 * - resourceRef : QName [0..*] (from: tResourceRole)
 * - resourceParameterBinding : tResourceParameterBinding [0..*] (from: tResourceRole)
 * - name : string [0..1] (from: tResourceRole)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tPotentialOwner : public tHumanPerformer {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tPotentialOwner"] = &createInstance<tPotentialOwner>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tPotentialOwner(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tPotentialOwner_H
#ifndef XML_bpmn_potentialOwner_H
#define XML_bpmn_potentialOwner_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  potentialOwner
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - resourceAssignmentExpression : tResourceAssignmentExpression [0..1] (from: tResourceRole)
 * - resourceRef : QName [0..*] (from: tResourceRole)
 * - resourceParameterBinding : tResourceParameterBinding [0..*] (from: tResourceRole)
 * - name : string [0..1] (from: tResourceRole)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class potentialOwner : public tPotentialOwner {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:potentialOwner"] = &createInstance<potentialOwner>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    potentialOwner(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_potentialOwner_H
#ifndef XML_bpmn_tRootElement_H
#define XML_bpmn_tRootElement_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tRootElement
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tRootElement : public tBaseElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tRootElement"] = &createInstance<tRootElement>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tRootElement(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
    friend class tDefinitions;
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tRootElement_H
#ifndef XML_bpmn_rootElement_H
#define XML_bpmn_rootElement_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  rootElement
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class rootElement : public tRootElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:rootElement"] = &createInstance<rootElement>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    rootElement(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_rootElement_H
#ifndef XML_bpmn_tCallableElement_H
#define XML_bpmn_tCallableElement_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tInputOutputSpecification;
class tInputOutputBinding;
 
/**
 * Overview:
 * - Element name:  tCallableElement
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - supportedInterfaceRef : QName [0..*]
 * - ioSpecification : tInputOutputSpecification [0..1]
 * - ioBinding : tInputOutputBinding [0..*]
 * - name : string [0..1]
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tCallableElement : public tRootElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tCallableElement"] = &createInstance<tCallableElement>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tCallableElement(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::vector< std::reference_wrapper<XMLObject> > supportedInterfaceRef;
    std::optional< std::reference_wrapper<tInputOutputSpecification> > ioSpecification;
    std::vector< std::reference_wrapper<tInputOutputBinding> > ioBinding;
    std::optional< std::reference_wrapper<Attribute> > name; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tCallableElement_H
#ifndef XML_bpmn_callableElement_H
#define XML_bpmn_callableElement_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  callableElement
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - supportedInterfaceRef : QName [0..*] (from: tCallableElement)
 * - ioSpecification : tInputOutputSpecification [0..1] (from: tCallableElement)
 * - ioBinding : tInputOutputBinding [0..*] (from: tCallableElement)
 * - name : string [0..1] (from: tCallableElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class callableElement : public tCallableElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:callableElement"] = &createInstance<callableElement>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    callableElement(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_callableElement_H
#ifndef XML_bpmn_tCategory_H
#define XML_bpmn_tCategory_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tCategoryValue;
 
/**
 * Overview:
 * - Element name:  tCategory
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - categoryValue : tCategoryValue [0..*]
 * - name : string [0..1]
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tCategory : public tRootElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tCategory"] = &createInstance<tCategory>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tCategory(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::vector< std::reference_wrapper<tCategoryValue> > categoryValue;
    std::optional< std::reference_wrapper<Attribute> > name; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tCategory_H
#ifndef XML_bpmn_category_H
#define XML_bpmn_category_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  category
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - categoryValue : tCategoryValue [0..*] (from: tCategory)
 * - name : string [0..1] (from: tCategory)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class category : public tCategory {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:category"] = &createInstance<category>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    category(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_category_H
#ifndef XML_bpmn_tCollaboration_H
#define XML_bpmn_tCollaboration_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tParticipant;
class tMessageFlow;
class tArtifact;
class tConversationNode;
class tConversationAssociation;
class tParticipantAssociation;
class tMessageFlowAssociation;
class tCorrelationKey;
class tConversationLink;
 
/**
 * Overview:
 * - Element name:  tCollaboration
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - participant : tParticipant [0..*]
 * - messageFlow : tMessageFlow [0..*]
 * - artifact : tArtifact [0..*]
 * - conversationNode : tConversationNode [0..*]
 * - conversationAssociation : tConversationAssociation [0..*]
 * - participantAssociation : tParticipantAssociation [0..*]
 * - messageFlowAssociation : tMessageFlowAssociation [0..*]
 * - correlationKey : tCorrelationKey [0..*]
 * - choreographyRef : QName [0..*]
 * - conversationLink : tConversationLink [0..*]
 * - name : string [0..1]
 * - isClosed : boolean [0..1]
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tCollaboration : public tRootElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tCollaboration"] = &createInstance<tCollaboration>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tCollaboration(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "isClosed", .value = Value(std::string("false"))}
    };
 
    std::vector< std::reference_wrapper<tParticipant> > participant;
    std::vector< std::reference_wrapper<tMessageFlow> > messageFlow;
    std::vector< std::reference_wrapper<tArtifact> > artifact;
    std::vector< std::reference_wrapper<tConversationNode> > conversationNode;
    std::vector< std::reference_wrapper<tConversationAssociation> > conversationAssociation;
    std::vector< std::reference_wrapper<tParticipantAssociation> > participantAssociation;
    std::vector< std::reference_wrapper<tMessageFlowAssociation> > messageFlowAssociation;
    std::vector< std::reference_wrapper<tCorrelationKey> > correlationKey;
    std::vector< std::reference_wrapper<XMLObject> > choreographyRef;
    std::vector< std::reference_wrapper<tConversationLink> > conversationLink;
    std::optional< std::reference_wrapper<Attribute> > name; ///< Attribute value can be expected to be of type 'std::string'
    std::optional< std::reference_wrapper<Attribute> > isClosed; ///< Attribute value can be expected to be of type 'bool'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tCollaboration_H
#ifndef XML_bpmn_collaboration_H
#define XML_bpmn_collaboration_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  collaboration
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - participant : tParticipant [0..*] (from: tCollaboration)
 * - messageFlow : tMessageFlow [0..*] (from: tCollaboration)
 * - artifact : tArtifact [0..*] (from: tCollaboration)
 * - conversationNode : tConversationNode [0..*] (from: tCollaboration)
 * - conversationAssociation : tConversationAssociation [0..*] (from: tCollaboration)
 * - participantAssociation : tParticipantAssociation [0..*] (from: tCollaboration)
 * - messageFlowAssociation : tMessageFlowAssociation [0..*] (from: tCollaboration)
 * - correlationKey : tCorrelationKey [0..*] (from: tCollaboration)
 * - choreographyRef : QName [0..*] (from: tCollaboration)
 * - conversationLink : tConversationLink [0..*] (from: tCollaboration)
 * - name : string [0..1] (from: tCollaboration)
 * - isClosed : boolean [0..1] (from: tCollaboration)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class collaboration : public tCollaboration {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:collaboration"] = &createInstance<collaboration>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    collaboration(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "isClosed", .value = Value(std::string("false"))}
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_collaboration_H
#ifndef XML_bpmn_tChoreography_H
#define XML_bpmn_tChoreography_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tFlowElement;
 
/**
 * Overview:
 * - Element name:  tChoreography
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - flowElement : tFlowElement [0..*]
 * - participant : tParticipant [0..*] (from: tCollaboration)
 * - messageFlow : tMessageFlow [0..*] (from: tCollaboration)
 * - artifact : tArtifact [0..*] (from: tCollaboration)
 * - conversationNode : tConversationNode [0..*] (from: tCollaboration)
 * - conversationAssociation : tConversationAssociation [0..*] (from: tCollaboration)
 * - participantAssociation : tParticipantAssociation [0..*] (from: tCollaboration)
 * - messageFlowAssociation : tMessageFlowAssociation [0..*] (from: tCollaboration)
 * - correlationKey : tCorrelationKey [0..*] (from: tCollaboration)
 * - choreographyRef : QName [0..*] (from: tCollaboration)
 * - conversationLink : tConversationLink [0..*] (from: tCollaboration)
 * - name : string [0..1] (from: tCollaboration)
 * - isClosed : boolean [0..1] (from: tCollaboration)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tChoreography : public tCollaboration {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tChoreography"] = &createInstance<tChoreography>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tChoreography(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "isClosed", .value = Value(std::string("false"))}
    };
 
    std::vector< std::reference_wrapper<tFlowElement> > flowElement;
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tChoreography_H
#ifndef XML_bpmn_choreography_H
#define XML_bpmn_choreography_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  choreography
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - flowElement : tFlowElement [0..*] (from: tChoreography)
 * - participant : tParticipant [0..*] (from: tCollaboration)
 * - messageFlow : tMessageFlow [0..*] (from: tCollaboration)
 * - artifact : tArtifact [0..*] (from: tCollaboration)
 * - conversationNode : tConversationNode [0..*] (from: tCollaboration)
 * - conversationAssociation : tConversationAssociation [0..*] (from: tCollaboration)
 * - participantAssociation : tParticipantAssociation [0..*] (from: tCollaboration)
 * - messageFlowAssociation : tMessageFlowAssociation [0..*] (from: tCollaboration)
 * - correlationKey : tCorrelationKey [0..*] (from: tCollaboration)
 * - choreographyRef : QName [0..*] (from: tCollaboration)
 * - conversationLink : tConversationLink [0..*] (from: tCollaboration)
 * - name : string [0..1] (from: tCollaboration)
 * - isClosed : boolean [0..1] (from: tCollaboration)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class choreography : public tChoreography {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:choreography"] = &createInstance<choreography>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    choreography(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "isClosed", .value = Value(std::string("false"))}
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_choreography_H
#ifndef XML_bpmn_tCorrelationProperty_H
#define XML_bpmn_tCorrelationProperty_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tCorrelationPropertyRetrievalExpression;
 
/**
 * Overview:
 * - Element name:  tCorrelationProperty
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - correlationPropertyRetrievalExpression : tCorrelationPropertyRetrievalExpression [1..*]
 * - name : string [0..1]
 * - type : QName [0..1]
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tCorrelationProperty : public tRootElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tCorrelationProperty"] = &createInstance<tCorrelationProperty>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tCorrelationProperty(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::vector< std::reference_wrapper<tCorrelationPropertyRetrievalExpression> > correlationPropertyRetrievalExpression;
    std::optional< std::reference_wrapper<Attribute> > name; ///< Attribute value can be expected to be of type 'std::string'
    std::optional< std::reference_wrapper<Attribute> > type; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tCorrelationProperty_H
#ifndef XML_bpmn_correlationProperty_H
#define XML_bpmn_correlationProperty_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  correlationProperty
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - correlationPropertyRetrievalExpression : tCorrelationPropertyRetrievalExpression [1..*] (from: tCorrelationProperty)
 * - name : string [0..1] (from: tCorrelationProperty)
 * - type : QName [0..1] (from: tCorrelationProperty)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class correlationProperty : public tCorrelationProperty {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:correlationProperty"] = &createInstance<correlationProperty>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    correlationProperty(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_correlationProperty_H
#ifndef XML_bpmn_tDataStore_H
#define XML_bpmn_tDataStore_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tDataState;
 
/**
 * Overview:
 * - Element name:  tDataStore
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - dataState : tDataState [0..1]
 * - name : string [0..1]
 * - capacity : integer [0..1]
 * - isUnlimited : boolean [0..1]
 * - itemSubjectRef : QName [0..1]
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tDataStore : public tRootElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tDataStore"] = &createInstance<tDataStore>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tDataStore(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "isUnlimited", .value = Value(std::string("true"))}
    };
 
    std::optional< std::reference_wrapper<tDataState> > dataState;
    std::optional< std::reference_wrapper<Attribute> > name; ///< Attribute value can be expected to be of type 'std::string'
    std::optional< std::reference_wrapper<Attribute> > capacity; ///< Attribute value can be expected to be of type 'int'
    std::optional< std::reference_wrapper<Attribute> > isUnlimited; ///< Attribute value can be expected to be of type 'bool'
    std::optional< std::reference_wrapper<Attribute> > itemSubjectRef; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tDataStore_H
#ifndef XML_bpmn_dataStore_H
#define XML_bpmn_dataStore_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  dataStore
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - dataState : tDataState [0..1] (from: tDataStore)
 * - name : string [0..1] (from: tDataStore)
 * - capacity : integer [0..1] (from: tDataStore)
 * - isUnlimited : boolean [0..1] (from: tDataStore)
 * - itemSubjectRef : QName [0..1] (from: tDataStore)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class dataStore : public tDataStore {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:dataStore"] = &createInstance<dataStore>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    dataStore(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "isUnlimited", .value = Value(std::string("true"))}
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_dataStore_H
#ifndef XML_bpmn_tEndPoint_H
#define XML_bpmn_tEndPoint_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tEndPoint
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tEndPoint : public tRootElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tEndPoint"] = &createInstance<tEndPoint>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tEndPoint(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tEndPoint_H
#ifndef XML_bpmn_endPoint_H
#define XML_bpmn_endPoint_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  endPoint
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class endPoint : public tEndPoint {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:endPoint"] = &createInstance<endPoint>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    endPoint(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_endPoint_H
#ifndef XML_bpmn_tError_H
#define XML_bpmn_tError_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tError
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - name : string [0..1]
 * - errorCode : string [0..1]
 * - structureRef : QName [0..1]
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tError : public tRootElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tError"] = &createInstance<tError>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tError(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::optional< std::reference_wrapper<Attribute> > name; ///< Attribute value can be expected to be of type 'std::string'
    std::optional< std::reference_wrapper<Attribute> > errorCode; ///< Attribute value can be expected to be of type 'std::string'
    std::optional< std::reference_wrapper<Attribute> > structureRef; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tError_H
#ifndef XML_bpmn_error_H
#define XML_bpmn_error_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  error
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - name : string [0..1] (from: tError)
 * - errorCode : string [0..1] (from: tError)
 * - structureRef : QName [0..1] (from: tError)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class error : public tError {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:error"] = &createInstance<error>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    error(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_error_H
#ifndef XML_bpmn_tEscalation_H
#define XML_bpmn_tEscalation_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tEscalation
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - name : string [0..1]
 * - escalationCode : string [0..1]
 * - structureRef : QName [0..1]
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tEscalation : public tRootElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tEscalation"] = &createInstance<tEscalation>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tEscalation(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::optional< std::reference_wrapper<Attribute> > name; ///< Attribute value can be expected to be of type 'std::string'
    std::optional< std::reference_wrapper<Attribute> > escalationCode; ///< Attribute value can be expected to be of type 'std::string'
    std::optional< std::reference_wrapper<Attribute> > structureRef; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tEscalation_H
#ifndef XML_bpmn_escalation_H
#define XML_bpmn_escalation_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  escalation
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - name : string [0..1] (from: tEscalation)
 * - escalationCode : string [0..1] (from: tEscalation)
 * - structureRef : QName [0..1] (from: tEscalation)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class escalation : public tEscalation {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:escalation"] = &createInstance<escalation>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    escalation(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_escalation_H
#ifndef XML_bpmn_tEventDefinition_H
#define XML_bpmn_tEventDefinition_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tEventDefinition
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tEventDefinition : public tRootElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tEventDefinition"] = &createInstance<tEventDefinition>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tEventDefinition(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
    friend class tCatchEvent;
    friend class tThrowEvent;
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tEventDefinition_H
#ifndef XML_bpmn_eventDefinition_H
#define XML_bpmn_eventDefinition_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  eventDefinition
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class eventDefinition : public tEventDefinition {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:eventDefinition"] = &createInstance<eventDefinition>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    eventDefinition(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_eventDefinition_H
#ifndef XML_bpmn_tCancelEventDefinition_H
#define XML_bpmn_tCancelEventDefinition_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tCancelEventDefinition
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tCancelEventDefinition : public tEventDefinition {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tCancelEventDefinition"] = &createInstance<tCancelEventDefinition>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tCancelEventDefinition(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tCancelEventDefinition_H
#ifndef XML_bpmn_cancelEventDefinition_H
#define XML_bpmn_cancelEventDefinition_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  cancelEventDefinition
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class cancelEventDefinition : public tCancelEventDefinition {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:cancelEventDefinition"] = &createInstance<cancelEventDefinition>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    cancelEventDefinition(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_cancelEventDefinition_H
#ifndef XML_bpmn_tCompensateEventDefinition_H
#define XML_bpmn_tCompensateEventDefinition_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tCompensateEventDefinition
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - waitForCompletion : boolean [0..1]
 * - activityRef : QName [0..1]
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tCompensateEventDefinition : public tEventDefinition {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tCompensateEventDefinition"] = &createInstance<tCompensateEventDefinition>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tCompensateEventDefinition(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::optional< std::reference_wrapper<Attribute> > waitForCompletion; ///< Attribute value can be expected to be of type 'bool'
    std::optional< std::reference_wrapper<Attribute> > activityRef; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tCompensateEventDefinition_H
#ifndef XML_bpmn_compensateEventDefinition_H
#define XML_bpmn_compensateEventDefinition_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  compensateEventDefinition
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - waitForCompletion : boolean [0..1] (from: tCompensateEventDefinition)
 * - activityRef : QName [0..1] (from: tCompensateEventDefinition)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class compensateEventDefinition : public tCompensateEventDefinition {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:compensateEventDefinition"] = &createInstance<compensateEventDefinition>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    compensateEventDefinition(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_compensateEventDefinition_H
#ifndef XML_bpmn_tConditionalEventDefinition_H
#define XML_bpmn_tConditionalEventDefinition_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tExpression;
 
/**
 * Overview:
 * - Element name:  tConditionalEventDefinition
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - condition : tExpression [0..*]
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tConditionalEventDefinition : public tEventDefinition {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tConditionalEventDefinition"] = &createInstance<tConditionalEventDefinition>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tConditionalEventDefinition(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::vector< std::reference_wrapper<tExpression> > condition;
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tConditionalEventDefinition_H
#ifndef XML_bpmn_conditionalEventDefinition_H
#define XML_bpmn_conditionalEventDefinition_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  conditionalEventDefinition
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - condition : tExpression [0..*] (from: tConditionalEventDefinition)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class conditionalEventDefinition : public tConditionalEventDefinition {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:conditionalEventDefinition"] = &createInstance<conditionalEventDefinition>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    conditionalEventDefinition(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_conditionalEventDefinition_H
#ifndef XML_bpmn_tErrorEventDefinition_H
#define XML_bpmn_tErrorEventDefinition_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tErrorEventDefinition
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - errorRef : QName [0..1]
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tErrorEventDefinition : public tEventDefinition {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tErrorEventDefinition"] = &createInstance<tErrorEventDefinition>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tErrorEventDefinition(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::optional< std::reference_wrapper<Attribute> > errorRef; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tErrorEventDefinition_H
#ifndef XML_bpmn_errorEventDefinition_H
#define XML_bpmn_errorEventDefinition_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  errorEventDefinition
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - errorRef : QName [0..1] (from: tErrorEventDefinition)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class errorEventDefinition : public tErrorEventDefinition {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:errorEventDefinition"] = &createInstance<errorEventDefinition>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    errorEventDefinition(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_errorEventDefinition_H
#ifndef XML_bpmn_tEscalationEventDefinition_H
#define XML_bpmn_tEscalationEventDefinition_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tEscalationEventDefinition
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - escalationRef : QName [0..1]
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tEscalationEventDefinition : public tEventDefinition {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tEscalationEventDefinition"] = &createInstance<tEscalationEventDefinition>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tEscalationEventDefinition(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::optional< std::reference_wrapper<Attribute> > escalationRef; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tEscalationEventDefinition_H
#ifndef XML_bpmn_escalationEventDefinition_H
#define XML_bpmn_escalationEventDefinition_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  escalationEventDefinition
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - escalationRef : QName [0..1] (from: tEscalationEventDefinition)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class escalationEventDefinition : public tEscalationEventDefinition {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:escalationEventDefinition"] = &createInstance<escalationEventDefinition>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    escalationEventDefinition(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_escalationEventDefinition_H
#ifndef XML_bpmn_tGlobalChoreographyTask_H
#define XML_bpmn_tGlobalChoreographyTask_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tGlobalChoreographyTask
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - initiatingParticipantRef : QName [0..1]
 * - flowElement : tFlowElement [0..*] (from: tChoreography)
 * - participant : tParticipant [0..*] (from: tCollaboration)
 * - messageFlow : tMessageFlow [0..*] (from: tCollaboration)
 * - artifact : tArtifact [0..*] (from: tCollaboration)
 * - conversationNode : tConversationNode [0..*] (from: tCollaboration)
 * - conversationAssociation : tConversationAssociation [0..*] (from: tCollaboration)
 * - participantAssociation : tParticipantAssociation [0..*] (from: tCollaboration)
 * - messageFlowAssociation : tMessageFlowAssociation [0..*] (from: tCollaboration)
 * - correlationKey : tCorrelationKey [0..*] (from: tCollaboration)
 * - choreographyRef : QName [0..*] (from: tCollaboration)
 * - conversationLink : tConversationLink [0..*] (from: tCollaboration)
 * - name : string [0..1] (from: tCollaboration)
 * - isClosed : boolean [0..1] (from: tCollaboration)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tGlobalChoreographyTask : public tChoreography {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tGlobalChoreographyTask"] = &createInstance<tGlobalChoreographyTask>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tGlobalChoreographyTask(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "isClosed", .value = Value(std::string("false"))}
    };
 
    std::optional< std::reference_wrapper<Attribute> > initiatingParticipantRef; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tGlobalChoreographyTask_H
#ifndef XML_bpmn_globalChoreographyTask_H
#define XML_bpmn_globalChoreographyTask_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  globalChoreographyTask
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - initiatingParticipantRef : QName [0..1] (from: tGlobalChoreographyTask)
 * - flowElement : tFlowElement [0..*] (from: tChoreography)
 * - participant : tParticipant [0..*] (from: tCollaboration)
 * - messageFlow : tMessageFlow [0..*] (from: tCollaboration)
 * - artifact : tArtifact [0..*] (from: tCollaboration)
 * - conversationNode : tConversationNode [0..*] (from: tCollaboration)
 * - conversationAssociation : tConversationAssociation [0..*] (from: tCollaboration)
 * - participantAssociation : tParticipantAssociation [0..*] (from: tCollaboration)
 * - messageFlowAssociation : tMessageFlowAssociation [0..*] (from: tCollaboration)
 * - correlationKey : tCorrelationKey [0..*] (from: tCollaboration)
 * - choreographyRef : QName [0..*] (from: tCollaboration)
 * - conversationLink : tConversationLink [0..*] (from: tCollaboration)
 * - name : string [0..1] (from: tCollaboration)
 * - isClosed : boolean [0..1] (from: tCollaboration)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class globalChoreographyTask : public tGlobalChoreographyTask {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:globalChoreographyTask"] = &createInstance<globalChoreographyTask>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    globalChoreographyTask(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "isClosed", .value = Value(std::string("false"))}
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_globalChoreographyTask_H
#ifndef XML_bpmn_tGlobalConversation_H
#define XML_bpmn_tGlobalConversation_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tGlobalConversation
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - participant : tParticipant [0..*] (from: tCollaboration)
 * - messageFlow : tMessageFlow [0..*] (from: tCollaboration)
 * - artifact : tArtifact [0..*] (from: tCollaboration)
 * - conversationNode : tConversationNode [0..*] (from: tCollaboration)
 * - conversationAssociation : tConversationAssociation [0..*] (from: tCollaboration)
 * - participantAssociation : tParticipantAssociation [0..*] (from: tCollaboration)
 * - messageFlowAssociation : tMessageFlowAssociation [0..*] (from: tCollaboration)
 * - correlationKey : tCorrelationKey [0..*] (from: tCollaboration)
 * - choreographyRef : QName [0..*] (from: tCollaboration)
 * - conversationLink : tConversationLink [0..*] (from: tCollaboration)
 * - name : string [0..1] (from: tCollaboration)
 * - isClosed : boolean [0..1] (from: tCollaboration)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tGlobalConversation : public tCollaboration {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tGlobalConversation"] = &createInstance<tGlobalConversation>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tGlobalConversation(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "isClosed", .value = Value(std::string("false"))}
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tGlobalConversation_H
#ifndef XML_bpmn_globalConversation_H
#define XML_bpmn_globalConversation_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  globalConversation
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - participant : tParticipant [0..*] (from: tCollaboration)
 * - messageFlow : tMessageFlow [0..*] (from: tCollaboration)
 * - artifact : tArtifact [0..*] (from: tCollaboration)
 * - conversationNode : tConversationNode [0..*] (from: tCollaboration)
 * - conversationAssociation : tConversationAssociation [0..*] (from: tCollaboration)
 * - participantAssociation : tParticipantAssociation [0..*] (from: tCollaboration)
 * - messageFlowAssociation : tMessageFlowAssociation [0..*] (from: tCollaboration)
 * - correlationKey : tCorrelationKey [0..*] (from: tCollaboration)
 * - choreographyRef : QName [0..*] (from: tCollaboration)
 * - conversationLink : tConversationLink [0..*] (from: tCollaboration)
 * - name : string [0..1] (from: tCollaboration)
 * - isClosed : boolean [0..1] (from: tCollaboration)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class globalConversation : public tGlobalConversation {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:globalConversation"] = &createInstance<globalConversation>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    globalConversation(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "isClosed", .value = Value(std::string("false"))}
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_globalConversation_H
#ifndef XML_bpmn_tGlobalTask_H
#define XML_bpmn_tGlobalTask_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tResourceRole;
 
/**
 * Overview:
 * - Element name:  tGlobalTask
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - resourceRole : tResourceRole [0..*]
 * - supportedInterfaceRef : QName [0..*] (from: tCallableElement)
 * - ioSpecification : tInputOutputSpecification [0..1] (from: tCallableElement)
 * - ioBinding : tInputOutputBinding [0..*] (from: tCallableElement)
 * - name : string [0..1] (from: tCallableElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tGlobalTask : public tCallableElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tGlobalTask"] = &createInstance<tGlobalTask>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tGlobalTask(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::vector< std::reference_wrapper<tResourceRole> > resourceRole;
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tGlobalTask_H
#ifndef XML_bpmn_globalTask_H
#define XML_bpmn_globalTask_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  globalTask
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - resourceRole : tResourceRole [0..*] (from: tGlobalTask)
 * - supportedInterfaceRef : QName [0..*] (from: tCallableElement)
 * - ioSpecification : tInputOutputSpecification [0..1] (from: tCallableElement)
 * - ioBinding : tInputOutputBinding [0..*] (from: tCallableElement)
 * - name : string [0..1] (from: tCallableElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class globalTask : public tGlobalTask {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:globalTask"] = &createInstance<globalTask>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    globalTask(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_globalTask_H
#ifndef XML_bpmn_tGlobalBusinessRuleTask_H
#define XML_bpmn_tGlobalBusinessRuleTask_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tImplementation;
 
/**
 * Overview:
 * - Element name:  tGlobalBusinessRuleTask
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - implementation : tImplementation [0..1]
 * - resourceRole : tResourceRole [0..*] (from: tGlobalTask)
 * - supportedInterfaceRef : QName [0..*] (from: tCallableElement)
 * - ioSpecification : tInputOutputSpecification [0..1] (from: tCallableElement)
 * - ioBinding : tInputOutputBinding [0..*] (from: tCallableElement)
 * - name : string [0..1] (from: tCallableElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tGlobalBusinessRuleTask : public tGlobalTask {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tGlobalBusinessRuleTask"] = &createInstance<tGlobalBusinessRuleTask>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tGlobalBusinessRuleTask(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "implementation", .value = Value(std::string("##unspecified"))}
    };
 
    std::optional< std::reference_wrapper<Attribute> > implementation; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tGlobalBusinessRuleTask_H
#ifndef XML_bpmn_globalBusinessRuleTask_H
#define XML_bpmn_globalBusinessRuleTask_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  globalBusinessRuleTask
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - implementation : tImplementation [0..1] (from: tGlobalBusinessRuleTask)
 * - resourceRole : tResourceRole [0..*] (from: tGlobalTask)
 * - supportedInterfaceRef : QName [0..*] (from: tCallableElement)
 * - ioSpecification : tInputOutputSpecification [0..1] (from: tCallableElement)
 * - ioBinding : tInputOutputBinding [0..*] (from: tCallableElement)
 * - name : string [0..1] (from: tCallableElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class globalBusinessRuleTask : public tGlobalBusinessRuleTask {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:globalBusinessRuleTask"] = &createInstance<globalBusinessRuleTask>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    globalBusinessRuleTask(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "implementation", .value = Value(std::string("##unspecified"))}
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_globalBusinessRuleTask_H
#ifndef XML_bpmn_tGlobalManualTask_H
#define XML_bpmn_tGlobalManualTask_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tGlobalManualTask
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - resourceRole : tResourceRole [0..*] (from: tGlobalTask)
 * - supportedInterfaceRef : QName [0..*] (from: tCallableElement)
 * - ioSpecification : tInputOutputSpecification [0..1] (from: tCallableElement)
 * - ioBinding : tInputOutputBinding [0..*] (from: tCallableElement)
 * - name : string [0..1] (from: tCallableElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tGlobalManualTask : public tGlobalTask {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tGlobalManualTask"] = &createInstance<tGlobalManualTask>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tGlobalManualTask(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tGlobalManualTask_H
#ifndef XML_bpmn_globalManualTask_H
#define XML_bpmn_globalManualTask_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  globalManualTask
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - resourceRole : tResourceRole [0..*] (from: tGlobalTask)
 * - supportedInterfaceRef : QName [0..*] (from: tCallableElement)
 * - ioSpecification : tInputOutputSpecification [0..1] (from: tCallableElement)
 * - ioBinding : tInputOutputBinding [0..*] (from: tCallableElement)
 * - name : string [0..1] (from: tCallableElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class globalManualTask : public tGlobalManualTask {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:globalManualTask"] = &createInstance<globalManualTask>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    globalManualTask(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_globalManualTask_H
#ifndef XML_bpmn_tGlobalScriptTask_H
#define XML_bpmn_tGlobalScriptTask_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tScript;
 
/**
 * Overview:
 * - Element name:  tGlobalScriptTask
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - script : tScript [0..1]
 * - scriptLanguage : anyURI [0..1]
 * - resourceRole : tResourceRole [0..*] (from: tGlobalTask)
 * - supportedInterfaceRef : QName [0..*] (from: tCallableElement)
 * - ioSpecification : tInputOutputSpecification [0..1] (from: tCallableElement)
 * - ioBinding : tInputOutputBinding [0..*] (from: tCallableElement)
 * - name : string [0..1] (from: tCallableElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tGlobalScriptTask : public tGlobalTask {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tGlobalScriptTask"] = &createInstance<tGlobalScriptTask>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tGlobalScriptTask(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::optional< std::reference_wrapper<tScript> > script;
    std::optional< std::reference_wrapper<Attribute> > scriptLanguage; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tGlobalScriptTask_H
#ifndef XML_bpmn_globalScriptTask_H
#define XML_bpmn_globalScriptTask_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  globalScriptTask
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - script : tScript [0..1] (from: tGlobalScriptTask)
 * - scriptLanguage : anyURI [0..1] (from: tGlobalScriptTask)
 * - resourceRole : tResourceRole [0..*] (from: tGlobalTask)
 * - supportedInterfaceRef : QName [0..*] (from: tCallableElement)
 * - ioSpecification : tInputOutputSpecification [0..1] (from: tCallableElement)
 * - ioBinding : tInputOutputBinding [0..*] (from: tCallableElement)
 * - name : string [0..1] (from: tCallableElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class globalScriptTask : public tGlobalScriptTask {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:globalScriptTask"] = &createInstance<globalScriptTask>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    globalScriptTask(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_globalScriptTask_H
#ifndef XML_bpmn_tGlobalUserTask_H
#define XML_bpmn_tGlobalUserTask_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tRendering;
class tImplementation;
 
/**
 * Overview:
 * - Element name:  tGlobalUserTask
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - rendering : tRendering [0..*]
 * - implementation : tImplementation [0..1]
 * - resourceRole : tResourceRole [0..*] (from: tGlobalTask)
 * - supportedInterfaceRef : QName [0..*] (from: tCallableElement)
 * - ioSpecification : tInputOutputSpecification [0..1] (from: tCallableElement)
 * - ioBinding : tInputOutputBinding [0..*] (from: tCallableElement)
 * - name : string [0..1] (from: tCallableElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tGlobalUserTask : public tGlobalTask {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tGlobalUserTask"] = &createInstance<tGlobalUserTask>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tGlobalUserTask(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "implementation", .value = Value(std::string("##unspecified"))}
    };
 
    std::vector< std::reference_wrapper<tRendering> > rendering;
    std::optional< std::reference_wrapper<Attribute> > implementation; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tGlobalUserTask_H
#ifndef XML_bpmn_globalUserTask_H
#define XML_bpmn_globalUserTask_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  globalUserTask
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - rendering : tRendering [0..*] (from: tGlobalUserTask)
 * - implementation : tImplementation [0..1] (from: tGlobalUserTask)
 * - resourceRole : tResourceRole [0..*] (from: tGlobalTask)
 * - supportedInterfaceRef : QName [0..*] (from: tCallableElement)
 * - ioSpecification : tInputOutputSpecification [0..1] (from: tCallableElement)
 * - ioBinding : tInputOutputBinding [0..*] (from: tCallableElement)
 * - name : string [0..1] (from: tCallableElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class globalUserTask : public tGlobalUserTask {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:globalUserTask"] = &createInstance<globalUserTask>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    globalUserTask(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "implementation", .value = Value(std::string("##unspecified"))}
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_globalUserTask_H
#ifndef XML_bpmn_tInterface_H
#define XML_bpmn_tInterface_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tOperation;
 
/**
 * Overview:
 * - Element name:  tInterface
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - operation : tOperation [1..*]
 * - name : string [1..1]
 * - implementationRef : QName [0..1]
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tInterface : public tRootElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tInterface"] = &createInstance<tInterface>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tInterface(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::vector< std::reference_wrapper<tOperation> > operation;
    Attribute& name; ///< Attribute value can be expected to be of type 'std::string'
    std::optional< std::reference_wrapper<Attribute> > implementationRef; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tInterface_H
#ifndef XML_bpmn_interface_H
#define XML_bpmn_interface_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  interface
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - operation : tOperation [1..*] (from: tInterface)
 * - name : string [1..1] (from: tInterface)
 * - implementationRef : QName [0..1] (from: tInterface)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class interface : public tInterface {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:interface"] = &createInstance<interface>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    interface(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_interface_H
#ifndef XML_bpmn_tItemDefinition_H
#define XML_bpmn_tItemDefinition_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tItemKind;
 
/**
 * Overview:
 * - Element name:  tItemDefinition
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - structureRef : QName [0..1]
 * - isCollection : boolean [0..1]
 * - itemKind : tItemKind [0..1]
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tItemDefinition : public tRootElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tItemDefinition"] = &createInstance<tItemDefinition>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tItemDefinition(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "isCollection", .value = Value(std::string("false"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "itemKind", .value = Value(std::string("Information"))}
    };
 
    std::optional< std::reference_wrapper<Attribute> > structureRef; ///< Attribute value can be expected to be of type 'std::string'
    std::optional< std::reference_wrapper<Attribute> > isCollection; ///< Attribute value can be expected to be of type 'bool'
    std::optional< std::reference_wrapper<Attribute> > itemKind; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tItemDefinition_H
#ifndef XML_bpmn_itemDefinition_H
#define XML_bpmn_itemDefinition_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  itemDefinition
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - structureRef : QName [0..1] (from: tItemDefinition)
 * - isCollection : boolean [0..1] (from: tItemDefinition)
 * - itemKind : tItemKind [0..1] (from: tItemDefinition)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class itemDefinition : public tItemDefinition {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:itemDefinition"] = &createInstance<itemDefinition>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    itemDefinition(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "isCollection", .value = Value(std::string("false"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "itemKind", .value = Value(std::string("Information"))}
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_itemDefinition_H
#ifndef XML_bpmn_tLinkEventDefinition_H
#define XML_bpmn_tLinkEventDefinition_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tLinkEventDefinition
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - source : QName [0..*]
 * - target : QName [0..1]
 * - name : string [1..1]
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tLinkEventDefinition : public tEventDefinition {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tLinkEventDefinition"] = &createInstance<tLinkEventDefinition>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tLinkEventDefinition(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::vector< std::reference_wrapper<XMLObject> > source;
    std::optional< std::reference_wrapper<XMLObject> > target;
    Attribute& name; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tLinkEventDefinition_H
#ifndef XML_bpmn_linkEventDefinition_H
#define XML_bpmn_linkEventDefinition_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  linkEventDefinition
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - source : QName [0..*] (from: tLinkEventDefinition)
 * - target : QName [0..1] (from: tLinkEventDefinition)
 * - name : string [1..1] (from: tLinkEventDefinition)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class linkEventDefinition : public tLinkEventDefinition {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:linkEventDefinition"] = &createInstance<linkEventDefinition>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    linkEventDefinition(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_linkEventDefinition_H
#ifndef XML_bpmn_tMessage_H
#define XML_bpmn_tMessage_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tMessage
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - name : string [0..1]
 * - itemRef : QName [0..1]
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tMessage : public tRootElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tMessage"] = &createInstance<tMessage>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tMessage(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::optional< std::reference_wrapper<Attribute> > name; ///< Attribute value can be expected to be of type 'std::string'
    std::optional< std::reference_wrapper<Attribute> > itemRef; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tMessage_H
#ifndef XML_bpmn_message_H
#define XML_bpmn_message_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  message
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - name : string [0..1] (from: tMessage)
 * - itemRef : QName [0..1] (from: tMessage)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class message : public tMessage {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:message"] = &createInstance<message>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    message(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_message_H
#ifndef XML_bpmn_tMessageEventDefinition_H
#define XML_bpmn_tMessageEventDefinition_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tMessageEventDefinition
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - operationRef : QName [0..1]
 * - messageRef : QName [0..1]
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tMessageEventDefinition : public tEventDefinition {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tMessageEventDefinition"] = &createInstance<tMessageEventDefinition>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tMessageEventDefinition(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::optional< std::reference_wrapper<XMLObject> > operationRef;
    std::optional< std::reference_wrapper<Attribute> > messageRef; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tMessageEventDefinition_H
#ifndef XML_bpmn_messageEventDefinition_H
#define XML_bpmn_messageEventDefinition_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  messageEventDefinition
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - operationRef : QName [0..1] (from: tMessageEventDefinition)
 * - messageRef : QName [0..1] (from: tMessageEventDefinition)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class messageEventDefinition : public tMessageEventDefinition {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:messageEventDefinition"] = &createInstance<messageEventDefinition>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    messageEventDefinition(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_messageEventDefinition_H
#ifndef XML_bpmn_tPartnerEntity_H
#define XML_bpmn_tPartnerEntity_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tPartnerEntity
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - participantRef : QName [0..*]
 * - name : string [0..1]
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tPartnerEntity : public tRootElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tPartnerEntity"] = &createInstance<tPartnerEntity>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tPartnerEntity(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::vector< std::reference_wrapper<XMLObject> > participantRef;
    std::optional< std::reference_wrapper<Attribute> > name; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tPartnerEntity_H
#ifndef XML_bpmn_partnerEntity_H
#define XML_bpmn_partnerEntity_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  partnerEntity
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - participantRef : QName [0..*] (from: tPartnerEntity)
 * - name : string [0..1] (from: tPartnerEntity)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class partnerEntity : public tPartnerEntity {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:partnerEntity"] = &createInstance<partnerEntity>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    partnerEntity(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_partnerEntity_H
#ifndef XML_bpmn_tPartnerRole_H
#define XML_bpmn_tPartnerRole_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tPartnerRole
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - participantRef : QName [0..*]
 * - name : string [0..1]
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tPartnerRole : public tRootElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tPartnerRole"] = &createInstance<tPartnerRole>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tPartnerRole(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::vector< std::reference_wrapper<XMLObject> > participantRef;
    std::optional< std::reference_wrapper<Attribute> > name; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tPartnerRole_H
#ifndef XML_bpmn_partnerRole_H
#define XML_bpmn_partnerRole_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  partnerRole
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - participantRef : QName [0..*] (from: tPartnerRole)
 * - name : string [0..1] (from: tPartnerRole)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class partnerRole : public tPartnerRole {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:partnerRole"] = &createInstance<partnerRole>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    partnerRole(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_partnerRole_H
#ifndef XML_bpmn_tProcess_H
#define XML_bpmn_tProcess_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tAuditing;
class tMonitoring;
class tProperty;
class tLaneSet;
class tFlowElement;
class tArtifact;
class tResourceRole;
class tCorrelationSubscription;
class tProcessType;
 
/**
 * Overview:
 * - Element name:  tProcess
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - auditing : tAuditing [0..1]
 * - monitoring : tMonitoring [0..1]
 * - property : tProperty [0..*]
 * - laneSet : tLaneSet [0..*]
 * - flowElement : tFlowElement [0..*]
 * - artifact : tArtifact [0..*]
 * - resourceRole : tResourceRole [0..*]
 * - correlationSubscription : tCorrelationSubscription [0..*]
 * - supports : QName [0..*]
 * - processType : tProcessType [0..1]
 * - isClosed : boolean [0..1]
 * - isExecutable : boolean [0..1]
 * - definitionalCollaborationRef : QName [0..1]
 * - supportedInterfaceRef : QName [0..*] (from: tCallableElement)
 * - ioSpecification : tInputOutputSpecification [0..1] (from: tCallableElement)
 * - ioBinding : tInputOutputBinding [0..*] (from: tCallableElement)
 * - name : string [0..1] (from: tCallableElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tProcess : public tCallableElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tProcess"] = &createInstance<tProcess>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tProcess(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
    friend class tDefinitions;
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "processType", .value = Value(std::string("None"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "isClosed", .value = Value(std::string("false"))}
    };
 
    std::optional< std::reference_wrapper<tAuditing> > auditing;
    std::optional< std::reference_wrapper<tMonitoring> > monitoring;
    std::vector< std::reference_wrapper<tProperty> > property;
    std::vector< std::reference_wrapper<tLaneSet> > laneSet;
    std::vector< std::reference_wrapper<tFlowElement> > flowElement;
    std::vector< std::reference_wrapper<tArtifact> > artifact;
    std::vector< std::reference_wrapper<tResourceRole> > resourceRole;
    std::vector< std::reference_wrapper<tCorrelationSubscription> > correlationSubscription;
    std::vector< std::reference_wrapper<XMLObject> > supports;
    std::optional< std::reference_wrapper<Attribute> > processType; ///< Attribute value can be expected to be of type 'std::string'
    std::optional< std::reference_wrapper<Attribute> > isClosed; ///< Attribute value can be expected to be of type 'bool'
    std::optional< std::reference_wrapper<Attribute> > isExecutable; ///< Attribute value can be expected to be of type 'bool'
    std::optional< std::reference_wrapper<Attribute> > definitionalCollaborationRef; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tProcess_H
#ifndef XML_bpmn_process_H
#define XML_bpmn_process_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  process
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - auditing : tAuditing [0..1] (from: tProcess)
 * - monitoring : tMonitoring [0..1] (from: tProcess)
 * - property : tProperty [0..*] (from: tProcess)
 * - laneSet : tLaneSet [0..*] (from: tProcess)
 * - flowElement : tFlowElement [0..*] (from: tProcess)
 * - artifact : tArtifact [0..*] (from: tProcess)
 * - resourceRole : tResourceRole [0..*] (from: tProcess)
 * - correlationSubscription : tCorrelationSubscription [0..*] (from: tProcess)
 * - supports : QName [0..*] (from: tProcess)
 * - processType : tProcessType [0..1] (from: tProcess)
 * - isClosed : boolean [0..1] (from: tProcess)
 * - isExecutable : boolean [0..1] (from: tProcess)
 * - definitionalCollaborationRef : QName [0..1] (from: tProcess)
 * - supportedInterfaceRef : QName [0..*] (from: tCallableElement)
 * - ioSpecification : tInputOutputSpecification [0..1] (from: tCallableElement)
 * - ioBinding : tInputOutputBinding [0..*] (from: tCallableElement)
 * - name : string [0..1] (from: tCallableElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class process : public tProcess {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:process"] = &createInstance<process>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    process(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "processType", .value = Value(std::string("None"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "isClosed", .value = Value(std::string("false"))}
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_process_H
#ifndef XML_bpmn_tResource_H
#define XML_bpmn_tResource_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tResourceParameter;
 
/**
 * Overview:
 * - Element name:  tResource
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - resourceParameter : tResourceParameter [0..*]
 * - name : string [1..1]
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tResource : public tRootElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tResource"] = &createInstance<tResource>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tResource(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::vector< std::reference_wrapper<tResourceParameter> > resourceParameter;
    Attribute& name; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tResource_H
#ifndef XML_bpmn_resource_H
#define XML_bpmn_resource_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  resource
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - resourceParameter : tResourceParameter [0..*] (from: tResource)
 * - name : string [1..1] (from: tResource)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class resource : public tResource {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:resource"] = &createInstance<resource>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    resource(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_resource_H
#ifndef XML_bpmn_tScript_H
#define XML_bpmn_tScript_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tScript
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tScript : public XMLObject {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tScript"] = &createInstance<tScript>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tScript(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
    friend class tGlobalScriptTask;
    friend class tScriptTask;
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tScript_H
#ifndef XML_bpmn_script_H
#define XML_bpmn_script_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  script
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class script : public tScript {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:script"] = &createInstance<script>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    script(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_script_H
#ifndef XML_bpmn_tSequenceFlow_H
#define XML_bpmn_tSequenceFlow_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tExpression;
 
/**
 * Overview:
 * - Element name:  tSequenceFlow
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - conditionExpression : tExpression [0..1]
 * - sourceRef : IDREF [1..1]
 * - targetRef : IDREF [1..1]
 * - isImmediate : boolean [0..1]
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tSequenceFlow : public tFlowElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tSequenceFlow"] = &createInstance<tSequenceFlow>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tSequenceFlow(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::optional< std::reference_wrapper<tExpression> > conditionExpression;
    Attribute& sourceRef; ///< Attribute value can be expected to be of type 'std::string'
    Attribute& targetRef; ///< Attribute value can be expected to be of type 'std::string'
    std::optional< std::reference_wrapper<Attribute> > isImmediate; ///< Attribute value can be expected to be of type 'bool'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tSequenceFlow_H
#ifndef XML_bpmn_sequenceFlow_H
#define XML_bpmn_sequenceFlow_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  sequenceFlow
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - conditionExpression : tExpression [0..1] (from: tSequenceFlow)
 * - sourceRef : IDREF [1..1] (from: tSequenceFlow)
 * - targetRef : IDREF [1..1] (from: tSequenceFlow)
 * - isImmediate : boolean [0..1] (from: tSequenceFlow)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class sequenceFlow : public tSequenceFlow {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:sequenceFlow"] = &createInstance<sequenceFlow>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    sequenceFlow(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_sequenceFlow_H
#ifndef XML_bpmn_tSignal_H
#define XML_bpmn_tSignal_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tSignal
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - name : string [0..1]
 * - structureRef : QName [0..1]
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tSignal : public tRootElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tSignal"] = &createInstance<tSignal>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tSignal(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::optional< std::reference_wrapper<Attribute> > name; ///< Attribute value can be expected to be of type 'std::string'
    std::optional< std::reference_wrapper<Attribute> > structureRef; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tSignal_H
#ifndef XML_bpmn_signal_H
#define XML_bpmn_signal_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  signal
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - name : string [0..1] (from: tSignal)
 * - structureRef : QName [0..1] (from: tSignal)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class signal : public tSignal {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:signal"] = &createInstance<signal>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    signal(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_signal_H
#ifndef XML_bpmn_tSignalEventDefinition_H
#define XML_bpmn_tSignalEventDefinition_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tSignalEventDefinition
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - signalRef : QName [0..1]
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tSignalEventDefinition : public tEventDefinition {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tSignalEventDefinition"] = &createInstance<tSignalEventDefinition>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tSignalEventDefinition(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::optional< std::reference_wrapper<Attribute> > signalRef; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tSignalEventDefinition_H
#ifndef XML_bpmn_signalEventDefinition_H
#define XML_bpmn_signalEventDefinition_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  signalEventDefinition
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - signalRef : QName [0..1] (from: tSignalEventDefinition)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class signalEventDefinition : public tSignalEventDefinition {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:signalEventDefinition"] = &createInstance<signalEventDefinition>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    signalEventDefinition(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_signalEventDefinition_H
#ifndef XML_bpmn_tStandardLoopCharacteristics_H
#define XML_bpmn_tStandardLoopCharacteristics_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tExpression;
 
/**
 * Overview:
 * - Element name:  tStandardLoopCharacteristics
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - loopCondition : tExpression [0..*]
 * - testBefore : boolean [0..1]
 * - loopMaximum : integer [0..1]
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tStandardLoopCharacteristics : public tLoopCharacteristics {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tStandardLoopCharacteristics"] = &createInstance<tStandardLoopCharacteristics>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tStandardLoopCharacteristics(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "testBefore", .value = Value(std::string("false"))}
    };
 
    std::vector< std::reference_wrapper<tExpression> > loopCondition;
    std::optional< std::reference_wrapper<Attribute> > testBefore; ///< Attribute value can be expected to be of type 'bool'
    std::optional< std::reference_wrapper<Attribute> > loopMaximum; ///< Attribute value can be expected to be of type 'int'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tStandardLoopCharacteristics_H
#ifndef XML_bpmn_standardLoopCharacteristics_H
#define XML_bpmn_standardLoopCharacteristics_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  standardLoopCharacteristics
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - loopCondition : tExpression [0..*] (from: tStandardLoopCharacteristics)
 * - testBefore : boolean [0..1] (from: tStandardLoopCharacteristics)
 * - loopMaximum : integer [0..1] (from: tStandardLoopCharacteristics)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class standardLoopCharacteristics : public tStandardLoopCharacteristics {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:standardLoopCharacteristics"] = &createInstance<standardLoopCharacteristics>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    standardLoopCharacteristics(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "testBefore", .value = Value(std::string("false"))}
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_standardLoopCharacteristics_H
#ifndef XML_bpmn_tStartEvent_H
#define XML_bpmn_tStartEvent_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tStartEvent
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - isInterrupting : boolean [0..1]
 * - dataOutput : tDataOutput [0..*] (from: tCatchEvent)
 * - dataOutputAssociation : tDataOutputAssociation [0..*] (from: tCatchEvent)
 * - outputSet : tOutputSet [0..1] (from: tCatchEvent)
 * - eventDefinition : tEventDefinition [0..*] (from: tCatchEvent)
 * - eventDefinitionRef : QName [0..*] (from: tCatchEvent)
 * - parallelMultiple : boolean [0..1] (from: tCatchEvent)
 * - property : tProperty [0..*] (from: tEvent)
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tStartEvent : public tCatchEvent {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tStartEvent"] = &createInstance<tStartEvent>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tStartEvent(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "isInterrupting", .value = Value(std::string("true"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "parallelMultiple", .value = Value(std::string("false"))}
    };
 
    std::optional< std::reference_wrapper<Attribute> > isInterrupting; ///< Attribute value can be expected to be of type 'bool'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tStartEvent_H
#ifndef XML_bpmn_startEvent_H
#define XML_bpmn_startEvent_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  startEvent
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - isInterrupting : boolean [0..1] (from: tStartEvent)
 * - dataOutput : tDataOutput [0..*] (from: tCatchEvent)
 * - dataOutputAssociation : tDataOutputAssociation [0..*] (from: tCatchEvent)
 * - outputSet : tOutputSet [0..1] (from: tCatchEvent)
 * - eventDefinition : tEventDefinition [0..*] (from: tCatchEvent)
 * - eventDefinitionRef : QName [0..*] (from: tCatchEvent)
 * - parallelMultiple : boolean [0..1] (from: tCatchEvent)
 * - property : tProperty [0..*] (from: tEvent)
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class startEvent : public tStartEvent {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:startEvent"] = &createInstance<startEvent>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    startEvent(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "isInterrupting", .value = Value(std::string("true"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "parallelMultiple", .value = Value(std::string("false"))}
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_startEvent_H
#ifndef XML_bpmn_tSubChoreography_H
#define XML_bpmn_tSubChoreography_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tFlowElement;
class tArtifact;
 
/**
 * Overview:
 * - Element name:  tSubChoreography
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - flowElement : tFlowElement [0..*]
 * - artifact : tArtifact [0..*]
 * - participantRef : QName [2..*] (from: tChoreographyActivity)
 * - correlationKey : tCorrelationKey [0..*] (from: tChoreographyActivity)
 * - initiatingParticipantRef : QName [1..1] (from: tChoreographyActivity)
 * - loopType : tChoreographyLoopType [0..1] (from: tChoreographyActivity)
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tSubChoreography : public tChoreographyActivity {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tSubChoreography"] = &createInstance<tSubChoreography>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tSubChoreography(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "loopType", .value = Value(std::string("None"))}
    };
 
    std::vector< std::reference_wrapper<tFlowElement> > flowElement;
    std::vector< std::reference_wrapper<tArtifact> > artifact;
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tSubChoreography_H
#ifndef XML_bpmn_subChoreography_H
#define XML_bpmn_subChoreography_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  subChoreography
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - flowElement : tFlowElement [0..*] (from: tSubChoreography)
 * - artifact : tArtifact [0..*] (from: tSubChoreography)
 * - participantRef : QName [2..*] (from: tChoreographyActivity)
 * - correlationKey : tCorrelationKey [0..*] (from: tChoreographyActivity)
 * - initiatingParticipantRef : QName [1..1] (from: tChoreographyActivity)
 * - loopType : tChoreographyLoopType [0..1] (from: tChoreographyActivity)
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class subChoreography : public tSubChoreography {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:subChoreography"] = &createInstance<subChoreography>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    subChoreography(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "loopType", .value = Value(std::string("None"))}
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_subChoreography_H
#ifndef XML_bpmn_tSubConversation_H
#define XML_bpmn_tSubConversation_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tConversationNode;
 
/**
 * Overview:
 * - Element name:  tSubConversation
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - conversationNode : tConversationNode [0..*]
 * - participantRef : QName [0..*] (from: tConversationNode)
 * - messageFlowRef : QName [0..*] (from: tConversationNode)
 * - correlationKey : tCorrelationKey [0..*] (from: tConversationNode)
 * - name : string [0..1] (from: tConversationNode)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tSubConversation : public tConversationNode {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tSubConversation"] = &createInstance<tSubConversation>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tSubConversation(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::vector< std::reference_wrapper<tConversationNode> > conversationNode;
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tSubConversation_H
#ifndef XML_bpmn_subConversation_H
#define XML_bpmn_subConversation_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  subConversation
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - conversationNode : tConversationNode [0..*] (from: tSubConversation)
 * - participantRef : QName [0..*] (from: tConversationNode)
 * - messageFlowRef : QName [0..*] (from: tConversationNode)
 * - correlationKey : tCorrelationKey [0..*] (from: tConversationNode)
 * - name : string [0..1] (from: tConversationNode)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class subConversation : public tSubConversation {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:subConversation"] = &createInstance<subConversation>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    subConversation(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_subConversation_H
#ifndef XML_bpmn_tSubProcess_H
#define XML_bpmn_tSubProcess_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tLaneSet;
class tFlowElement;
class tArtifact;
 
/**
 * Overview:
 * - Element name:  tSubProcess
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - laneSet : tLaneSet [0..*]
 * - flowElement : tFlowElement [0..*]
 * - artifact : tArtifact [0..*]
 * - triggeredByEvent : boolean [0..1]
 * - ioSpecification : tInputOutputSpecification [0..1] (from: tActivity)
 * - property : tProperty [0..*] (from: tActivity)
 * - dataInputAssociation : tDataInputAssociation [0..*] (from: tActivity)
 * - dataOutputAssociation : tDataOutputAssociation [0..*] (from: tActivity)
 * - resourceRole : tResourceRole [0..*] (from: tActivity)
 * - loopCharacteristics : tLoopCharacteristics [0..*] (from: tActivity)
 * - isForCompensation : boolean [0..1] (from: tActivity)
 * - startQuantity : integer [0..1] (from: tActivity)
 * - completionQuantity : integer [0..1] (from: tActivity)
 * - default : IDREF [0..1] (from: tActivity)
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tSubProcess : public tActivity {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tSubProcess"] = &createInstance<tSubProcess>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tSubProcess(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "triggeredByEvent", .value = Value(std::string("false"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "isForCompensation", .value = Value(std::string("false"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "startQuantity", .value = Value(std::string("1"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "completionQuantity", .value = Value(std::string("1"))}
    };
 
    std::vector< std::reference_wrapper<tLaneSet> > laneSet;
    std::vector< std::reference_wrapper<tFlowElement> > flowElement;
    std::vector< std::reference_wrapper<tArtifact> > artifact;
    std::optional< std::reference_wrapper<Attribute> > triggeredByEvent; ///< Attribute value can be expected to be of type 'bool'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tSubProcess_H
#ifndef XML_bpmn_subProcess_H
#define XML_bpmn_subProcess_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  subProcess
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - laneSet : tLaneSet [0..*] (from: tSubProcess)
 * - flowElement : tFlowElement [0..*] (from: tSubProcess)
 * - artifact : tArtifact [0..*] (from: tSubProcess)
 * - triggeredByEvent : boolean [0..1] (from: tSubProcess)
 * - ioSpecification : tInputOutputSpecification [0..1] (from: tActivity)
 * - property : tProperty [0..*] (from: tActivity)
 * - dataInputAssociation : tDataInputAssociation [0..*] (from: tActivity)
 * - dataOutputAssociation : tDataOutputAssociation [0..*] (from: tActivity)
 * - resourceRole : tResourceRole [0..*] (from: tActivity)
 * - loopCharacteristics : tLoopCharacteristics [0..*] (from: tActivity)
 * - isForCompensation : boolean [0..1] (from: tActivity)
 * - startQuantity : integer [0..1] (from: tActivity)
 * - completionQuantity : integer [0..1] (from: tActivity)
 * - default : IDREF [0..1] (from: tActivity)
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class subProcess : public tSubProcess {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:subProcess"] = &createInstance<subProcess>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    subProcess(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "triggeredByEvent", .value = Value(std::string("false"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "isForCompensation", .value = Value(std::string("false"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "startQuantity", .value = Value(std::string("1"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "completionQuantity", .value = Value(std::string("1"))}
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_subProcess_H
#ifndef XML_bpmn_tAdHocSubProcess_H
#define XML_bpmn_tAdHocSubProcess_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tExpression;
class tAdHocOrdering;
 
/**
 * Overview:
 * - Element name:  tAdHocSubProcess
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - completionCondition : tExpression [0..1]
 * - cancelRemainingInstances : boolean [0..1]
 * - ordering : tAdHocOrdering [0..1]
 * - laneSet : tLaneSet [0..*] (from: tSubProcess)
 * - flowElement : tFlowElement [0..*] (from: tSubProcess)
 * - artifact : tArtifact [0..*] (from: tSubProcess)
 * - triggeredByEvent : boolean [0..1] (from: tSubProcess)
 * - ioSpecification : tInputOutputSpecification [0..1] (from: tActivity)
 * - property : tProperty [0..*] (from: tActivity)
 * - dataInputAssociation : tDataInputAssociation [0..*] (from: tActivity)
 * - dataOutputAssociation : tDataOutputAssociation [0..*] (from: tActivity)
 * - resourceRole : tResourceRole [0..*] (from: tActivity)
 * - loopCharacteristics : tLoopCharacteristics [0..*] (from: tActivity)
 * - isForCompensation : boolean [0..1] (from: tActivity)
 * - startQuantity : integer [0..1] (from: tActivity)
 * - completionQuantity : integer [0..1] (from: tActivity)
 * - default : IDREF [0..1] (from: tActivity)
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tAdHocSubProcess : public tSubProcess {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tAdHocSubProcess"] = &createInstance<tAdHocSubProcess>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tAdHocSubProcess(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "cancelRemainingInstances", .value = Value(std::string("true"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "triggeredByEvent", .value = Value(std::string("false"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "isForCompensation", .value = Value(std::string("false"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "startQuantity", .value = Value(std::string("1"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "completionQuantity", .value = Value(std::string("1"))}
    };
 
    std::optional< std::reference_wrapper<tExpression> > completionCondition;
    std::optional< std::reference_wrapper<Attribute> > cancelRemainingInstances; ///< Attribute value can be expected to be of type 'bool'
    std::optional< std::reference_wrapper<Attribute> > ordering; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tAdHocSubProcess_H
#ifndef XML_bpmn_adHocSubProcess_H
#define XML_bpmn_adHocSubProcess_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  adHocSubProcess
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - completionCondition : tExpression [0..1] (from: tAdHocSubProcess)
 * - cancelRemainingInstances : boolean [0..1] (from: tAdHocSubProcess)
 * - ordering : tAdHocOrdering [0..1] (from: tAdHocSubProcess)
 * - laneSet : tLaneSet [0..*] (from: tSubProcess)
 * - flowElement : tFlowElement [0..*] (from: tSubProcess)
 * - artifact : tArtifact [0..*] (from: tSubProcess)
 * - triggeredByEvent : boolean [0..1] (from: tSubProcess)
 * - ioSpecification : tInputOutputSpecification [0..1] (from: tActivity)
 * - property : tProperty [0..*] (from: tActivity)
 * - dataInputAssociation : tDataInputAssociation [0..*] (from: tActivity)
 * - dataOutputAssociation : tDataOutputAssociation [0..*] (from: tActivity)
 * - resourceRole : tResourceRole [0..*] (from: tActivity)
 * - loopCharacteristics : tLoopCharacteristics [0..*] (from: tActivity)
 * - isForCompensation : boolean [0..1] (from: tActivity)
 * - startQuantity : integer [0..1] (from: tActivity)
 * - completionQuantity : integer [0..1] (from: tActivity)
 * - default : IDREF [0..1] (from: tActivity)
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class adHocSubProcess : public tAdHocSubProcess {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:adHocSubProcess"] = &createInstance<adHocSubProcess>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    adHocSubProcess(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "cancelRemainingInstances", .value = Value(std::string("true"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "triggeredByEvent", .value = Value(std::string("false"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "isForCompensation", .value = Value(std::string("false"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "startQuantity", .value = Value(std::string("1"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "completionQuantity", .value = Value(std::string("1"))}
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_adHocSubProcess_H
#ifndef XML_bpmn_tTask_H
#define XML_bpmn_tTask_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tTask
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - ioSpecification : tInputOutputSpecification [0..1] (from: tActivity)
 * - property : tProperty [0..*] (from: tActivity)
 * - dataInputAssociation : tDataInputAssociation [0..*] (from: tActivity)
 * - dataOutputAssociation : tDataOutputAssociation [0..*] (from: tActivity)
 * - resourceRole : tResourceRole [0..*] (from: tActivity)
 * - loopCharacteristics : tLoopCharacteristics [0..*] (from: tActivity)
 * - isForCompensation : boolean [0..1] (from: tActivity)
 * - startQuantity : integer [0..1] (from: tActivity)
 * - completionQuantity : integer [0..1] (from: tActivity)
 * - default : IDREF [0..1] (from: tActivity)
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tTask : public tActivity {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tTask"] = &createInstance<tTask>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tTask(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "isForCompensation", .value = Value(std::string("false"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "startQuantity", .value = Value(std::string("1"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "completionQuantity", .value = Value(std::string("1"))}
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tTask_H
#ifndef XML_bpmn_tBusinessRuleTask_H
#define XML_bpmn_tBusinessRuleTask_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tImplementation;
 
/**
 * Overview:
 * - Element name:  tBusinessRuleTask
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - implementation : tImplementation [0..1]
 * - ioSpecification : tInputOutputSpecification [0..1] (from: tActivity)
 * - property : tProperty [0..*] (from: tActivity)
 * - dataInputAssociation : tDataInputAssociation [0..*] (from: tActivity)
 * - dataOutputAssociation : tDataOutputAssociation [0..*] (from: tActivity)
 * - resourceRole : tResourceRole [0..*] (from: tActivity)
 * - loopCharacteristics : tLoopCharacteristics [0..*] (from: tActivity)
 * - isForCompensation : boolean [0..1] (from: tActivity)
 * - startQuantity : integer [0..1] (from: tActivity)
 * - completionQuantity : integer [0..1] (from: tActivity)
 * - default : IDREF [0..1] (from: tActivity)
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tBusinessRuleTask : public tTask {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tBusinessRuleTask"] = &createInstance<tBusinessRuleTask>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tBusinessRuleTask(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "implementation", .value = Value(std::string("##unspecified"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "isForCompensation", .value = Value(std::string("false"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "startQuantity", .value = Value(std::string("1"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "completionQuantity", .value = Value(std::string("1"))}
    };
 
    std::optional< std::reference_wrapper<Attribute> > implementation; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tBusinessRuleTask_H
#ifndef XML_bpmn_businessRuleTask_H
#define XML_bpmn_businessRuleTask_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  businessRuleTask
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - implementation : tImplementation [0..1] (from: tBusinessRuleTask)
 * - ioSpecification : tInputOutputSpecification [0..1] (from: tActivity)
 * - property : tProperty [0..*] (from: tActivity)
 * - dataInputAssociation : tDataInputAssociation [0..*] (from: tActivity)
 * - dataOutputAssociation : tDataOutputAssociation [0..*] (from: tActivity)
 * - resourceRole : tResourceRole [0..*] (from: tActivity)
 * - loopCharacteristics : tLoopCharacteristics [0..*] (from: tActivity)
 * - isForCompensation : boolean [0..1] (from: tActivity)
 * - startQuantity : integer [0..1] (from: tActivity)
 * - completionQuantity : integer [0..1] (from: tActivity)
 * - default : IDREF [0..1] (from: tActivity)
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class businessRuleTask : public tBusinessRuleTask {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:businessRuleTask"] = &createInstance<businessRuleTask>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    businessRuleTask(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "implementation", .value = Value(std::string("##unspecified"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "isForCompensation", .value = Value(std::string("false"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "startQuantity", .value = Value(std::string("1"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "completionQuantity", .value = Value(std::string("1"))}
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_businessRuleTask_H
#ifndef XML_bpmn_tManualTask_H
#define XML_bpmn_tManualTask_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tManualTask
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - ioSpecification : tInputOutputSpecification [0..1] (from: tActivity)
 * - property : tProperty [0..*] (from: tActivity)
 * - dataInputAssociation : tDataInputAssociation [0..*] (from: tActivity)
 * - dataOutputAssociation : tDataOutputAssociation [0..*] (from: tActivity)
 * - resourceRole : tResourceRole [0..*] (from: tActivity)
 * - loopCharacteristics : tLoopCharacteristics [0..*] (from: tActivity)
 * - isForCompensation : boolean [0..1] (from: tActivity)
 * - startQuantity : integer [0..1] (from: tActivity)
 * - completionQuantity : integer [0..1] (from: tActivity)
 * - default : IDREF [0..1] (from: tActivity)
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tManualTask : public tTask {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tManualTask"] = &createInstance<tManualTask>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tManualTask(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "isForCompensation", .value = Value(std::string("false"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "startQuantity", .value = Value(std::string("1"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "completionQuantity", .value = Value(std::string("1"))}
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tManualTask_H
#ifndef XML_bpmn_manualTask_H
#define XML_bpmn_manualTask_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  manualTask
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - ioSpecification : tInputOutputSpecification [0..1] (from: tActivity)
 * - property : tProperty [0..*] (from: tActivity)
 * - dataInputAssociation : tDataInputAssociation [0..*] (from: tActivity)
 * - dataOutputAssociation : tDataOutputAssociation [0..*] (from: tActivity)
 * - resourceRole : tResourceRole [0..*] (from: tActivity)
 * - loopCharacteristics : tLoopCharacteristics [0..*] (from: tActivity)
 * - isForCompensation : boolean [0..1] (from: tActivity)
 * - startQuantity : integer [0..1] (from: tActivity)
 * - completionQuantity : integer [0..1] (from: tActivity)
 * - default : IDREF [0..1] (from: tActivity)
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class manualTask : public tManualTask {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:manualTask"] = &createInstance<manualTask>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    manualTask(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "isForCompensation", .value = Value(std::string("false"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "startQuantity", .value = Value(std::string("1"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "completionQuantity", .value = Value(std::string("1"))}
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_manualTask_H
#ifndef XML_bpmn_tReceiveTask_H
#define XML_bpmn_tReceiveTask_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tImplementation;
 
/**
 * Overview:
 * - Element name:  tReceiveTask
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - implementation : tImplementation [0..1]
 * - instantiate : boolean [0..1]
 * - messageRef : QName [0..1]
 * - operationRef : QName [0..1]
 * - ioSpecification : tInputOutputSpecification [0..1] (from: tActivity)
 * - property : tProperty [0..*] (from: tActivity)
 * - dataInputAssociation : tDataInputAssociation [0..*] (from: tActivity)
 * - dataOutputAssociation : tDataOutputAssociation [0..*] (from: tActivity)
 * - resourceRole : tResourceRole [0..*] (from: tActivity)
 * - loopCharacteristics : tLoopCharacteristics [0..*] (from: tActivity)
 * - isForCompensation : boolean [0..1] (from: tActivity)
 * - startQuantity : integer [0..1] (from: tActivity)
 * - completionQuantity : integer [0..1] (from: tActivity)
 * - default : IDREF [0..1] (from: tActivity)
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tReceiveTask : public tTask {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tReceiveTask"] = &createInstance<tReceiveTask>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tReceiveTask(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "implementation", .value = Value(std::string("##WebService"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "instantiate", .value = Value(std::string("false"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "isForCompensation", .value = Value(std::string("false"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "startQuantity", .value = Value(std::string("1"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "completionQuantity", .value = Value(std::string("1"))}
    };
 
    std::optional< std::reference_wrapper<Attribute> > implementation; ///< Attribute value can be expected to be of type 'std::string'
    std::optional< std::reference_wrapper<Attribute> > instantiate; ///< Attribute value can be expected to be of type 'bool'
    std::optional< std::reference_wrapper<Attribute> > messageRef; ///< Attribute value can be expected to be of type 'std::string'
    std::optional< std::reference_wrapper<Attribute> > operationRef; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tReceiveTask_H
#ifndef XML_bpmn_receiveTask_H
#define XML_bpmn_receiveTask_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  receiveTask
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - implementation : tImplementation [0..1] (from: tReceiveTask)
 * - instantiate : boolean [0..1] (from: tReceiveTask)
 * - messageRef : QName [0..1] (from: tReceiveTask)
 * - operationRef : QName [0..1] (from: tReceiveTask)
 * - ioSpecification : tInputOutputSpecification [0..1] (from: tActivity)
 * - property : tProperty [0..*] (from: tActivity)
 * - dataInputAssociation : tDataInputAssociation [0..*] (from: tActivity)
 * - dataOutputAssociation : tDataOutputAssociation [0..*] (from: tActivity)
 * - resourceRole : tResourceRole [0..*] (from: tActivity)
 * - loopCharacteristics : tLoopCharacteristics [0..*] (from: tActivity)
 * - isForCompensation : boolean [0..1] (from: tActivity)
 * - startQuantity : integer [0..1] (from: tActivity)
 * - completionQuantity : integer [0..1] (from: tActivity)
 * - default : IDREF [0..1] (from: tActivity)
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class receiveTask : public tReceiveTask {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:receiveTask"] = &createInstance<receiveTask>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    receiveTask(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "implementation", .value = Value(std::string("##WebService"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "instantiate", .value = Value(std::string("false"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "isForCompensation", .value = Value(std::string("false"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "startQuantity", .value = Value(std::string("1"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "completionQuantity", .value = Value(std::string("1"))}
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_receiveTask_H
#ifndef XML_bpmn_tScriptTask_H
#define XML_bpmn_tScriptTask_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tScript;
 
/**
 * Overview:
 * - Element name:  tScriptTask
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - script : tScript [0..1]
 * - scriptFormat : string [0..1]
 * - ioSpecification : tInputOutputSpecification [0..1] (from: tActivity)
 * - property : tProperty [0..*] (from: tActivity)
 * - dataInputAssociation : tDataInputAssociation [0..*] (from: tActivity)
 * - dataOutputAssociation : tDataOutputAssociation [0..*] (from: tActivity)
 * - resourceRole : tResourceRole [0..*] (from: tActivity)
 * - loopCharacteristics : tLoopCharacteristics [0..*] (from: tActivity)
 * - isForCompensation : boolean [0..1] (from: tActivity)
 * - startQuantity : integer [0..1] (from: tActivity)
 * - completionQuantity : integer [0..1] (from: tActivity)
 * - default : IDREF [0..1] (from: tActivity)
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tScriptTask : public tTask {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tScriptTask"] = &createInstance<tScriptTask>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tScriptTask(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "isForCompensation", .value = Value(std::string("false"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "startQuantity", .value = Value(std::string("1"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "completionQuantity", .value = Value(std::string("1"))}
    };
 
    std::optional< std::reference_wrapper<tScript> > script;
    std::optional< std::reference_wrapper<Attribute> > scriptFormat; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tScriptTask_H
#ifndef XML_bpmn_scriptTask_H
#define XML_bpmn_scriptTask_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  scriptTask
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - script : tScript [0..1] (from: tScriptTask)
 * - scriptFormat : string [0..1] (from: tScriptTask)
 * - ioSpecification : tInputOutputSpecification [0..1] (from: tActivity)
 * - property : tProperty [0..*] (from: tActivity)
 * - dataInputAssociation : tDataInputAssociation [0..*] (from: tActivity)
 * - dataOutputAssociation : tDataOutputAssociation [0..*] (from: tActivity)
 * - resourceRole : tResourceRole [0..*] (from: tActivity)
 * - loopCharacteristics : tLoopCharacteristics [0..*] (from: tActivity)
 * - isForCompensation : boolean [0..1] (from: tActivity)
 * - startQuantity : integer [0..1] (from: tActivity)
 * - completionQuantity : integer [0..1] (from: tActivity)
 * - default : IDREF [0..1] (from: tActivity)
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class scriptTask : public tScriptTask {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:scriptTask"] = &createInstance<scriptTask>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    scriptTask(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "isForCompensation", .value = Value(std::string("false"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "startQuantity", .value = Value(std::string("1"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "completionQuantity", .value = Value(std::string("1"))}
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_scriptTask_H
#ifndef XML_bpmn_tSendTask_H
#define XML_bpmn_tSendTask_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tImplementation;
 
/**
 * Overview:
 * - Element name:  tSendTask
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - implementation : tImplementation [0..1]
 * - messageRef : QName [0..1]
 * - operationRef : QName [0..1]
 * - ioSpecification : tInputOutputSpecification [0..1] (from: tActivity)
 * - property : tProperty [0..*] (from: tActivity)
 * - dataInputAssociation : tDataInputAssociation [0..*] (from: tActivity)
 * - dataOutputAssociation : tDataOutputAssociation [0..*] (from: tActivity)
 * - resourceRole : tResourceRole [0..*] (from: tActivity)
 * - loopCharacteristics : tLoopCharacteristics [0..*] (from: tActivity)
 * - isForCompensation : boolean [0..1] (from: tActivity)
 * - startQuantity : integer [0..1] (from: tActivity)
 * - completionQuantity : integer [0..1] (from: tActivity)
 * - default : IDREF [0..1] (from: tActivity)
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tSendTask : public tTask {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tSendTask"] = &createInstance<tSendTask>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tSendTask(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "implementation", .value = Value(std::string("##WebService"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "isForCompensation", .value = Value(std::string("false"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "startQuantity", .value = Value(std::string("1"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "completionQuantity", .value = Value(std::string("1"))}
    };
 
    std::optional< std::reference_wrapper<Attribute> > implementation; ///< Attribute value can be expected to be of type 'std::string'
    std::optional< std::reference_wrapper<Attribute> > messageRef; ///< Attribute value can be expected to be of type 'std::string'
    std::optional< std::reference_wrapper<Attribute> > operationRef; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tSendTask_H
#ifndef XML_bpmn_sendTask_H
#define XML_bpmn_sendTask_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  sendTask
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - implementation : tImplementation [0..1] (from: tSendTask)
 * - messageRef : QName [0..1] (from: tSendTask)
 * - operationRef : QName [0..1] (from: tSendTask)
 * - ioSpecification : tInputOutputSpecification [0..1] (from: tActivity)
 * - property : tProperty [0..*] (from: tActivity)
 * - dataInputAssociation : tDataInputAssociation [0..*] (from: tActivity)
 * - dataOutputAssociation : tDataOutputAssociation [0..*] (from: tActivity)
 * - resourceRole : tResourceRole [0..*] (from: tActivity)
 * - loopCharacteristics : tLoopCharacteristics [0..*] (from: tActivity)
 * - isForCompensation : boolean [0..1] (from: tActivity)
 * - startQuantity : integer [0..1] (from: tActivity)
 * - completionQuantity : integer [0..1] (from: tActivity)
 * - default : IDREF [0..1] (from: tActivity)
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class sendTask : public tSendTask {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:sendTask"] = &createInstance<sendTask>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    sendTask(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "implementation", .value = Value(std::string("##WebService"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "isForCompensation", .value = Value(std::string("false"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "startQuantity", .value = Value(std::string("1"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "completionQuantity", .value = Value(std::string("1"))}
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_sendTask_H
#ifndef XML_bpmn_tServiceTask_H
#define XML_bpmn_tServiceTask_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tImplementation;
 
/**
 * Overview:
 * - Element name:  tServiceTask
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - implementation : tImplementation [0..1]
 * - operationRef : QName [0..1]
 * - ioSpecification : tInputOutputSpecification [0..1] (from: tActivity)
 * - property : tProperty [0..*] (from: tActivity)
 * - dataInputAssociation : tDataInputAssociation [0..*] (from: tActivity)
 * - dataOutputAssociation : tDataOutputAssociation [0..*] (from: tActivity)
 * - resourceRole : tResourceRole [0..*] (from: tActivity)
 * - loopCharacteristics : tLoopCharacteristics [0..*] (from: tActivity)
 * - isForCompensation : boolean [0..1] (from: tActivity)
 * - startQuantity : integer [0..1] (from: tActivity)
 * - completionQuantity : integer [0..1] (from: tActivity)
 * - default : IDREF [0..1] (from: tActivity)
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tServiceTask : public tTask {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tServiceTask"] = &createInstance<tServiceTask>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tServiceTask(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "implementation", .value = Value(std::string("##WebService"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "isForCompensation", .value = Value(std::string("false"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "startQuantity", .value = Value(std::string("1"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "completionQuantity", .value = Value(std::string("1"))}
    };
 
    std::optional< std::reference_wrapper<Attribute> > implementation; ///< Attribute value can be expected to be of type 'std::string'
    std::optional< std::reference_wrapper<Attribute> > operationRef; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tServiceTask_H
#ifndef XML_bpmn_serviceTask_H
#define XML_bpmn_serviceTask_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  serviceTask
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - implementation : tImplementation [0..1] (from: tServiceTask)
 * - operationRef : QName [0..1] (from: tServiceTask)
 * - ioSpecification : tInputOutputSpecification [0..1] (from: tActivity)
 * - property : tProperty [0..*] (from: tActivity)
 * - dataInputAssociation : tDataInputAssociation [0..*] (from: tActivity)
 * - dataOutputAssociation : tDataOutputAssociation [0..*] (from: tActivity)
 * - resourceRole : tResourceRole [0..*] (from: tActivity)
 * - loopCharacteristics : tLoopCharacteristics [0..*] (from: tActivity)
 * - isForCompensation : boolean [0..1] (from: tActivity)
 * - startQuantity : integer [0..1] (from: tActivity)
 * - completionQuantity : integer [0..1] (from: tActivity)
 * - default : IDREF [0..1] (from: tActivity)
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class serviceTask : public tServiceTask {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:serviceTask"] = &createInstance<serviceTask>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    serviceTask(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "implementation", .value = Value(std::string("##WebService"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "isForCompensation", .value = Value(std::string("false"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "startQuantity", .value = Value(std::string("1"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "completionQuantity", .value = Value(std::string("1"))}
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_serviceTask_H
#ifndef XML_bpmn_tTerminateEventDefinition_H
#define XML_bpmn_tTerminateEventDefinition_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tTerminateEventDefinition
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tTerminateEventDefinition : public tEventDefinition {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tTerminateEventDefinition"] = &createInstance<tTerminateEventDefinition>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tTerminateEventDefinition(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tTerminateEventDefinition_H
#ifndef XML_bpmn_tText_H
#define XML_bpmn_tText_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tText
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tText : public XMLObject {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tText"] = &createInstance<tText>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tText(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
    friend class tTextAnnotation;
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tText_H
#ifndef XML_bpmn_tTextAnnotation_H
#define XML_bpmn_tTextAnnotation_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tText;
 
/**
 * Overview:
 * - Element name:  tTextAnnotation
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - text : tText [0..1]
 * - textFormat : string [0..1]
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tTextAnnotation : public tArtifact {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tTextAnnotation"] = &createInstance<tTextAnnotation>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tTextAnnotation(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "textFormat", .value = Value(std::string("text/plain"))}
    };
 
    std::optional< std::reference_wrapper<tText> > text;
    std::optional< std::reference_wrapper<Attribute> > textFormat; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tTextAnnotation_H
#ifndef XML_bpmn_tThrowEvent_H
#define XML_bpmn_tThrowEvent_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tDataInput;
class tDataInputAssociation;
class tInputSet;
class tEventDefinition;
 
/**
 * Overview:
 * - Element name:  tThrowEvent
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - dataInput : tDataInput [0..*]
 * - dataInputAssociation : tDataInputAssociation [0..*]
 * - inputSet : tInputSet [0..1]
 * - eventDefinition : tEventDefinition [0..*]
 * - eventDefinitionRef : QName [0..*]
 * - property : tProperty [0..*] (from: tEvent)
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tThrowEvent : public tEvent {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tThrowEvent"] = &createInstance<tThrowEvent>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tThrowEvent(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::vector< std::reference_wrapper<tDataInput> > dataInput;
    std::vector< std::reference_wrapper<tDataInputAssociation> > dataInputAssociation;
    std::optional< std::reference_wrapper<tInputSet> > inputSet;
    std::vector< std::reference_wrapper<tEventDefinition> > eventDefinition;
    std::vector< std::reference_wrapper<XMLObject> > eventDefinitionRef;
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tThrowEvent_H
#ifndef XML_bpmn_tEndEvent_H
#define XML_bpmn_tEndEvent_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tEndEvent
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - dataInput : tDataInput [0..*] (from: tThrowEvent)
 * - dataInputAssociation : tDataInputAssociation [0..*] (from: tThrowEvent)
 * - inputSet : tInputSet [0..1] (from: tThrowEvent)
 * - eventDefinition : tEventDefinition [0..*] (from: tThrowEvent)
 * - eventDefinitionRef : QName [0..*] (from: tThrowEvent)
 * - property : tProperty [0..*] (from: tEvent)
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tEndEvent : public tThrowEvent {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tEndEvent"] = &createInstance<tEndEvent>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tEndEvent(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tEndEvent_H
#ifndef XML_bpmn_endEvent_H
#define XML_bpmn_endEvent_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  endEvent
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - dataInput : tDataInput [0..*] (from: tThrowEvent)
 * - dataInputAssociation : tDataInputAssociation [0..*] (from: tThrowEvent)
 * - inputSet : tInputSet [0..1] (from: tThrowEvent)
 * - eventDefinition : tEventDefinition [0..*] (from: tThrowEvent)
 * - eventDefinitionRef : QName [0..*] (from: tThrowEvent)
 * - property : tProperty [0..*] (from: tEvent)
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class endEvent : public tEndEvent {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:endEvent"] = &createInstance<endEvent>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    endEvent(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_endEvent_H
#ifndef XML_bpmn_tImplicitThrowEvent_H
#define XML_bpmn_tImplicitThrowEvent_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tImplicitThrowEvent
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - dataInput : tDataInput [0..*] (from: tThrowEvent)
 * - dataInputAssociation : tDataInputAssociation [0..*] (from: tThrowEvent)
 * - inputSet : tInputSet [0..1] (from: tThrowEvent)
 * - eventDefinition : tEventDefinition [0..*] (from: tThrowEvent)
 * - eventDefinitionRef : QName [0..*] (from: tThrowEvent)
 * - property : tProperty [0..*] (from: tEvent)
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tImplicitThrowEvent : public tThrowEvent {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tImplicitThrowEvent"] = &createInstance<tImplicitThrowEvent>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tImplicitThrowEvent(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
    friend class tComplexBehaviorDefinition;
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tImplicitThrowEvent_H
#ifndef XML_bpmn_implicitThrowEvent_H
#define XML_bpmn_implicitThrowEvent_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  implicitThrowEvent
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - dataInput : tDataInput [0..*] (from: tThrowEvent)
 * - dataInputAssociation : tDataInputAssociation [0..*] (from: tThrowEvent)
 * - inputSet : tInputSet [0..1] (from: tThrowEvent)
 * - eventDefinition : tEventDefinition [0..*] (from: tThrowEvent)
 * - eventDefinitionRef : QName [0..*] (from: tThrowEvent)
 * - property : tProperty [0..*] (from: tEvent)
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class implicitThrowEvent : public tImplicitThrowEvent {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:implicitThrowEvent"] = &createInstance<implicitThrowEvent>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    implicitThrowEvent(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_implicitThrowEvent_H
#ifndef XML_bpmn_tIntermediateThrowEvent_H
#define XML_bpmn_tIntermediateThrowEvent_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  tIntermediateThrowEvent
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - dataInput : tDataInput [0..*] (from: tThrowEvent)
 * - dataInputAssociation : tDataInputAssociation [0..*] (from: tThrowEvent)
 * - inputSet : tInputSet [0..1] (from: tThrowEvent)
 * - eventDefinition : tEventDefinition [0..*] (from: tThrowEvent)
 * - eventDefinitionRef : QName [0..*] (from: tThrowEvent)
 * - property : tProperty [0..*] (from: tEvent)
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tIntermediateThrowEvent : public tThrowEvent {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tIntermediateThrowEvent"] = &createInstance<tIntermediateThrowEvent>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tIntermediateThrowEvent(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tIntermediateThrowEvent_H
#ifndef XML_bpmn_intermediateThrowEvent_H
#define XML_bpmn_intermediateThrowEvent_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  intermediateThrowEvent
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - dataInput : tDataInput [0..*] (from: tThrowEvent)
 * - dataInputAssociation : tDataInputAssociation [0..*] (from: tThrowEvent)
 * - inputSet : tInputSet [0..1] (from: tThrowEvent)
 * - eventDefinition : tEventDefinition [0..*] (from: tThrowEvent)
 * - eventDefinitionRef : QName [0..*] (from: tThrowEvent)
 * - property : tProperty [0..*] (from: tEvent)
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class intermediateThrowEvent : public tIntermediateThrowEvent {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:intermediateThrowEvent"] = &createInstance<intermediateThrowEvent>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    intermediateThrowEvent(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_intermediateThrowEvent_H
#ifndef XML_bpmn_tTimerEventDefinition_H
#define XML_bpmn_tTimerEventDefinition_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tExpression;
class tExpression;
class tExpression;
 
/**
 * Overview:
 * - Element name:  tTimerEventDefinition
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - timeDate : tExpression [0..1]
 * - timeDuration : tExpression [0..1]
 * - timeCycle : tExpression [0..1]
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tTimerEventDefinition : public tEventDefinition {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tTimerEventDefinition"] = &createInstance<tTimerEventDefinition>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tTimerEventDefinition(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::optional< std::reference_wrapper<tExpression> > timeDate;
    std::optional< std::reference_wrapper<tExpression> > timeDuration;
    std::optional< std::reference_wrapper<tExpression> > timeCycle;
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tTimerEventDefinition_H
#ifndef XML_bpmn_tTransaction_H
#define XML_bpmn_tTransaction_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tTransactionMethod;
 
/**
 * Overview:
 * - Element name:  tTransaction
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - method : tTransactionMethod [0..1]
 * - laneSet : tLaneSet [0..*] (from: tSubProcess)
 * - flowElement : tFlowElement [0..*] (from: tSubProcess)
 * - artifact : tArtifact [0..*] (from: tSubProcess)
 * - triggeredByEvent : boolean [0..1] (from: tSubProcess)
 * - ioSpecification : tInputOutputSpecification [0..1] (from: tActivity)
 * - property : tProperty [0..*] (from: tActivity)
 * - dataInputAssociation : tDataInputAssociation [0..*] (from: tActivity)
 * - dataOutputAssociation : tDataOutputAssociation [0..*] (from: tActivity)
 * - resourceRole : tResourceRole [0..*] (from: tActivity)
 * - loopCharacteristics : tLoopCharacteristics [0..*] (from: tActivity)
 * - isForCompensation : boolean [0..1] (from: tActivity)
 * - startQuantity : integer [0..1] (from: tActivity)
 * - completionQuantity : integer [0..1] (from: tActivity)
 * - default : IDREF [0..1] (from: tActivity)
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tTransaction : public tSubProcess {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tTransaction"] = &createInstance<tTransaction>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tTransaction(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "method", .value = Value(std::string("##Compensate"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "triggeredByEvent", .value = Value(std::string("false"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "isForCompensation", .value = Value(std::string("false"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "startQuantity", .value = Value(std::string("1"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "completionQuantity", .value = Value(std::string("1"))}
    };
 
    std::optional< std::reference_wrapper<Attribute> > method; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tTransaction_H
#ifndef XML_bpmn_tUserTask_H
#define XML_bpmn_tUserTask_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class tRendering;
class tImplementation;
 
/**
 * Overview:
 * - Element name:  tUserTask
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - rendering : tRendering [0..*]
 * - implementation : tImplementation [0..1]
 * - ioSpecification : tInputOutputSpecification [0..1] (from: tActivity)
 * - property : tProperty [0..*] (from: tActivity)
 * - dataInputAssociation : tDataInputAssociation [0..*] (from: tActivity)
 * - dataOutputAssociation : tDataOutputAssociation [0..*] (from: tActivity)
 * - resourceRole : tResourceRole [0..*] (from: tActivity)
 * - loopCharacteristics : tLoopCharacteristics [0..*] (from: tActivity)
 * - isForCompensation : boolean [0..1] (from: tActivity)
 * - startQuantity : integer [0..1] (from: tActivity)
 * - completionQuantity : integer [0..1] (from: tActivity)
 * - default : IDREF [0..1] (from: tActivity)
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class tUserTask : public tTask {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:tUserTask"] = &createInstance<tUserTask>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    tUserTask(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "implementation", .value = Value(std::string("##unspecified"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "isForCompensation", .value = Value(std::string("false"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "startQuantity", .value = Value(std::string("1"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "completionQuantity", .value = Value(std::string("1"))}
    };
 
    std::vector< std::reference_wrapper<tRendering> > rendering;
    std::optional< std::reference_wrapper<Attribute> > implementation; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_tUserTask_H
#ifndef XML_bpmn_task_H
#define XML_bpmn_task_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  task
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - ioSpecification : tInputOutputSpecification [0..1] (from: tActivity)
 * - property : tProperty [0..*] (from: tActivity)
 * - dataInputAssociation : tDataInputAssociation [0..*] (from: tActivity)
 * - dataOutputAssociation : tDataOutputAssociation [0..*] (from: tActivity)
 * - resourceRole : tResourceRole [0..*] (from: tActivity)
 * - loopCharacteristics : tLoopCharacteristics [0..*] (from: tActivity)
 * - isForCompensation : boolean [0..1] (from: tActivity)
 * - startQuantity : integer [0..1] (from: tActivity)
 * - completionQuantity : integer [0..1] (from: tActivity)
 * - default : IDREF [0..1] (from: tActivity)
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class task : public tTask {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:task"] = &createInstance<task>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    task(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "isForCompensation", .value = Value(std::string("false"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "startQuantity", .value = Value(std::string("1"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "completionQuantity", .value = Value(std::string("1"))}
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_task_H
#ifndef XML_bpmn_terminateEventDefinition_H
#define XML_bpmn_terminateEventDefinition_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  terminateEventDefinition
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class terminateEventDefinition : public tTerminateEventDefinition {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:terminateEventDefinition"] = &createInstance<terminateEventDefinition>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    terminateEventDefinition(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_terminateEventDefinition_H
#ifndef XML_bpmn_text_H
#define XML_bpmn_text_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  text
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class text : public tText {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:text"] = &createInstance<text>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    text(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_text_H
#ifndef XML_bpmn_textAnnotation_H
#define XML_bpmn_textAnnotation_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  textAnnotation
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - text : tText [0..1] (from: tTextAnnotation)
 * - textFormat : string [0..1] (from: tTextAnnotation)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class textAnnotation : public tTextAnnotation {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:textAnnotation"] = &createInstance<textAnnotation>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    textAnnotation(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "textFormat", .value = Value(std::string("text/plain"))}
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_textAnnotation_H
#ifndef XML_bpmn_throwEvent_H
#define XML_bpmn_throwEvent_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  throwEvent
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - dataInput : tDataInput [0..*] (from: tThrowEvent)
 * - dataInputAssociation : tDataInputAssociation [0..*] (from: tThrowEvent)
 * - inputSet : tInputSet [0..1] (from: tThrowEvent)
 * - eventDefinition : tEventDefinition [0..*] (from: tThrowEvent)
 * - eventDefinitionRef : QName [0..*] (from: tThrowEvent)
 * - property : tProperty [0..*] (from: tEvent)
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class throwEvent : public tThrowEvent {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:throwEvent"] = &createInstance<throwEvent>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    throwEvent(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_throwEvent_H
#ifndef XML_bpmn_timerEventDefinition_H
#define XML_bpmn_timerEventDefinition_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  timerEventDefinition
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - timeDate : tExpression [0..1] (from: tTimerEventDefinition)
 * - timeDuration : tExpression [0..1] (from: tTimerEventDefinition)
 * - timeCycle : tExpression [0..1] (from: tTimerEventDefinition)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class timerEventDefinition : public tTimerEventDefinition {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:timerEventDefinition"] = &createInstance<timerEventDefinition>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    timerEventDefinition(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_timerEventDefinition_H
#ifndef XML_bpmn_transaction_H
#define XML_bpmn_transaction_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  transaction
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - method : tTransactionMethod [0..1] (from: tTransaction)
 * - laneSet : tLaneSet [0..*] (from: tSubProcess)
 * - flowElement : tFlowElement [0..*] (from: tSubProcess)
 * - artifact : tArtifact [0..*] (from: tSubProcess)
 * - triggeredByEvent : boolean [0..1] (from: tSubProcess)
 * - ioSpecification : tInputOutputSpecification [0..1] (from: tActivity)
 * - property : tProperty [0..*] (from: tActivity)
 * - dataInputAssociation : tDataInputAssociation [0..*] (from: tActivity)
 * - dataOutputAssociation : tDataOutputAssociation [0..*] (from: tActivity)
 * - resourceRole : tResourceRole [0..*] (from: tActivity)
 * - loopCharacteristics : tLoopCharacteristics [0..*] (from: tActivity)
 * - isForCompensation : boolean [0..1] (from: tActivity)
 * - startQuantity : integer [0..1] (from: tActivity)
 * - completionQuantity : integer [0..1] (from: tActivity)
 * - default : IDREF [0..1] (from: tActivity)
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class transaction : public tTransaction {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:transaction"] = &createInstance<transaction>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    transaction(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "method", .value = Value(std::string("##Compensate"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "triggeredByEvent", .value = Value(std::string("false"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "isForCompensation", .value = Value(std::string("false"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "startQuantity", .value = Value(std::string("1"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "completionQuantity", .value = Value(std::string("1"))}
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_transaction_H
#ifndef XML_bpmn_userTask_H
#define XML_bpmn_userTask_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  userTask
 * - XML-Schema:    xsd/Semantic.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/MODEL
 *
 * Members:
 * - rendering : tRendering [0..*] (from: tUserTask)
 * - implementation : tImplementation [0..1] (from: tUserTask)
 * - ioSpecification : tInputOutputSpecification [0..1] (from: tActivity)
 * - property : tProperty [0..*] (from: tActivity)
 * - dataInputAssociation : tDataInputAssociation [0..*] (from: tActivity)
 * - dataOutputAssociation : tDataOutputAssociation [0..*] (from: tActivity)
 * - resourceRole : tResourceRole [0..*] (from: tActivity)
 * - loopCharacteristics : tLoopCharacteristics [0..*] (from: tActivity)
 * - isForCompensation : boolean [0..1] (from: tActivity)
 * - startQuantity : integer [0..1] (from: tActivity)
 * - completionQuantity : integer [0..1] (from: tActivity)
 * - default : IDREF [0..1] (from: tActivity)
 * - incoming : QName [0..*] (from: tFlowNode)
 * - outgoing : QName [0..*] (from: tFlowNode)
 * - auditing : tAuditing [0..1] (from: tFlowElement)
 * - monitoring : tMonitoring [0..1] (from: tFlowElement)
 * - categoryValueRef : QName [0..*] (from: tFlowElement)
 * - name : string [0..1] (from: tFlowElement)
 * - documentation : tDocumentation [0..*] (from: tBaseElement)
 * - extensionElements : tExtensionElements [0..1] (from: tBaseElement)
 * - id : ID [0..1] (from: tBaseElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class userTask : public tUserTask {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/MODEL:userTask"] = &createInstance<userTask>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    userTask(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "implementation", .value = Value(std::string("##unspecified"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "isForCompensation", .value = Value(std::string("false"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "startQuantity", .value = Value(std::string("1"))},
        { .xmlns = "http://www.omg.org/spec/BPMN/20100524/MODEL", .prefix = "" , .name = "completionQuantity", .value = Value(std::string("1"))}
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_userTask_H
#ifndef XML_bpmn_Bounds_H
#define XML_bpmn_Bounds_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  Bounds
 * - XML-Schema:    xsd/DC.xsd
 * - XML-Namespace: http://www.omg.org/spec/DD/20100524/DC
 *
 * Members:
 * - x : double [1..1]
 * - y : double [1..1]
 * - width : double [1..1]
 * - height : double [1..1]
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class Bounds : public XMLObject {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/DD/20100524/DC:Bounds"] = &createInstance<Bounds>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    Bounds(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
    friend class Label;
    friend class Shape;
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    Attribute& x; ///< Attribute value can be expected to be of type 'double'
    Attribute& y; ///< Attribute value can be expected to be of type 'double'
    Attribute& width; ///< Attribute value can be expected to be of type 'double'
    Attribute& height; ///< Attribute value can be expected to be of type 'double'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_Bounds_H
#ifndef XML_bpmn_Font_H
#define XML_bpmn_Font_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  Font
 * - XML-Schema:    xsd/DC.xsd
 * - XML-Namespace: http://www.omg.org/spec/DD/20100524/DC
 *
 * Members:
 * - name : string [0..1]
 * - size : double [0..1]
 * - isBold : boolean [0..1]
 * - isItalic : boolean [0..1]
 * - isUnderline : boolean [0..1]
 * - isStrikeThrough : boolean [0..1]
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class Font : public XMLObject {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/DD/20100524/DC:Font"] = &createInstance<Font>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    Font(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
    friend class BPMNLabelStyle;
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::optional< std::reference_wrapper<Attribute> > name; ///< Attribute value can be expected to be of type 'std::string'
    std::optional< std::reference_wrapper<Attribute> > size; ///< Attribute value can be expected to be of type 'double'
    std::optional< std::reference_wrapper<Attribute> > isBold; ///< Attribute value can be expected to be of type 'bool'
    std::optional< std::reference_wrapper<Attribute> > isItalic; ///< Attribute value can be expected to be of type 'bool'
    std::optional< std::reference_wrapper<Attribute> > isUnderline; ///< Attribute value can be expected to be of type 'bool'
    std::optional< std::reference_wrapper<Attribute> > isStrikeThrough; ///< Attribute value can be expected to be of type 'bool'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_Font_H
#ifndef XML_bpmn_Point_H
#define XML_bpmn_Point_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  Point
 * - XML-Schema:    xsd/DC.xsd
 * - XML-Namespace: http://www.omg.org/spec/DD/20100524/DC
 *
 * Members:
 * - x : double [1..1]
 * - y : double [1..1]
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class Point : public XMLObject {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/DD/20100524/DC:Point"] = &createInstance<Point>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    Point(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
    friend class Edge;
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    Attribute& x; ///< Attribute value can be expected to be of type 'double'
    Attribute& y; ///< Attribute value can be expected to be of type 'double'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_Point_H
#ifndef XML_bpmn_Diagram_H
#define XML_bpmn_Diagram_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  Diagram
 * - XML-Schema:    xsd/DI.xsd
 * - XML-Namespace: http://www.omg.org/spec/DD/20100524/DI
 *
 * Members:
 * - name : string [0..1]
 * - documentation : string [0..1]
 * - resolution : double [0..1]
 * - id : ID [0..1]
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class Diagram : public XMLObject {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/DD/20100524/DI:Diagram"] = &createInstance<Diagram>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    Diagram(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::optional< std::reference_wrapper<Attribute> > name; ///< Attribute value can be expected to be of type 'std::string'
    std::optional< std::reference_wrapper<Attribute> > documentation; ///< Attribute value can be expected to be of type 'std::string'
    std::optional< std::reference_wrapper<Attribute> > resolution; ///< Attribute value can be expected to be of type 'double'
    std::optional< std::reference_wrapper<Attribute> > id; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_Diagram_H
#ifndef XML_bpmn_BPMNDiagram_H
#define XML_bpmn_BPMNDiagram_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class BPMNPlane;
class BPMNLabelStyle;
 
/**
 * Overview:
 * - Element name:  BPMNDiagram
 * - XML-Schema:    xsd/BPMNDI.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/DI
 *
 * Members:
 * - bpmndi_BPMNPlane : BPMNPlane [0..*]
 * - bpmndi_BPMNLabelStyle : BPMNLabelStyle [0..*]
 * - name : string [0..1] (from: Diagram)
 * - documentation : string [0..1] (from: Diagram)
 * - resolution : double [0..1] (from: Diagram)
 * - id : ID [0..1] (from: Diagram)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class BPMNDiagram : public Diagram {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/DI:BPMNDiagram"] = &createInstance<BPMNDiagram>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    BPMNDiagram(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
    friend class tDefinitions;
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::vector< std::reference_wrapper<BPMNPlane> > bpmndi_BPMNPlane;
    std::vector< std::reference_wrapper<BPMNLabelStyle> > bpmndi_BPMNLabelStyle;
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_BPMNDiagram_H
#ifndef XML_bpmn_DiagramElement_H
#define XML_bpmn_DiagramElement_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class DiagramElement_extension;
 
/**
 * Overview:
 * - Element name:  DiagramElement
 * - XML-Schema:    xsd/DI.xsd
 * - XML-Namespace: http://www.omg.org/spec/DD/20100524/DI
 *
 * Members:
 * - extension : DiagramElement_extension [0..*]
 * - id : ID [0..1]
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class DiagramElement : public XMLObject {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/DD/20100524/DI:DiagramElement"] = &createInstance<DiagramElement>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    DiagramElement(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
    friend class Plane;
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::vector< std::reference_wrapper<DiagramElement_extension> > extension;
    std::optional< std::reference_wrapper<Attribute> > id; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_DiagramElement_H
#ifndef XML_bpmn_DiagramElement_extension_H
#define XML_bpmn_DiagramElement_extension_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  DiagramElement_extension
 * - XML-Schema:    xsd/DI.xsd
 * - XML-Namespace: http://www.omg.org/spec/DD/20100524/DI
 *
 * Members:
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class DiagramElement_extension : public XMLObject {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/DD/20100524/DI:DiagramElement_extension"] = &createInstance<DiagramElement_extension>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    DiagramElement_extension(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
    friend class DiagramElement;
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_DiagramElement_extension_H
#ifndef XML_bpmn_Edge_H
#define XML_bpmn_Edge_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class Point;
 
/**
 * Overview:
 * - Element name:  Edge
 * - XML-Schema:    xsd/DI.xsd
 * - XML-Namespace: http://www.omg.org/spec/DD/20100524/DI
 *
 * Members:
 * - waypoint : Point [2..*]
 * - extension : DiagramElement_extension [0..*] (from: DiagramElement)
 * - id : ID [0..1] (from: DiagramElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class Edge : public DiagramElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/DD/20100524/DI:Edge"] = &createInstance<Edge>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    Edge(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::vector< std::reference_wrapper<Point> > waypoint;
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_Edge_H
#ifndef XML_bpmn_LabeledEdge_H
#define XML_bpmn_LabeledEdge_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  LabeledEdge
 * - XML-Schema:    xsd/DI.xsd
 * - XML-Namespace: http://www.omg.org/spec/DD/20100524/DI
 *
 * Members:
 * - waypoint : Point [2..*] (from: Edge)
 * - extension : DiagramElement_extension [0..*] (from: DiagramElement)
 * - id : ID [0..1] (from: DiagramElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class LabeledEdge : public Edge {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/DD/20100524/DI:LabeledEdge"] = &createInstance<LabeledEdge>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    LabeledEdge(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_LabeledEdge_H
#ifndef XML_bpmn_BPMNEdge_H
#define XML_bpmn_BPMNEdge_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class BPMNLabel;
class MessageVisibleKind;
 
/**
 * Overview:
 * - Element name:  BPMNEdge
 * - XML-Schema:    xsd/BPMNDI.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/DI
 *
 * Members:
 * - bpmndi_BPMNLabel : BPMNLabel [0..*]
 * - bpmnElement : QName [0..1]
 * - sourceElement : QName [0..1]
 * - targetElement : QName [0..1]
 * - messageVisibleKind : MessageVisibleKind [0..1]
 * - waypoint : Point [2..*] (from: Edge)
 * - extension : DiagramElement_extension [0..*] (from: DiagramElement)
 * - id : ID [0..1] (from: DiagramElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class BPMNEdge : public LabeledEdge {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/DI:BPMNEdge"] = &createInstance<BPMNEdge>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    BPMNEdge(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::vector< std::reference_wrapper<BPMNLabel> > bpmndi_BPMNLabel;
    std::optional< std::reference_wrapper<Attribute> > bpmnElement; ///< Attribute value can be expected to be of type 'std::string'
    std::optional< std::reference_wrapper<Attribute> > sourceElement; ///< Attribute value can be expected to be of type 'std::string'
    std::optional< std::reference_wrapper<Attribute> > targetElement; ///< Attribute value can be expected to be of type 'std::string'
    std::optional< std::reference_wrapper<Attribute> > messageVisibleKind; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_BPMNEdge_H
#ifndef XML_bpmn_Node_H
#define XML_bpmn_Node_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  Node
 * - XML-Schema:    xsd/DI.xsd
 * - XML-Namespace: http://www.omg.org/spec/DD/20100524/DI
 *
 * Members:
 * - extension : DiagramElement_extension [0..*] (from: DiagramElement)
 * - id : ID [0..1] (from: DiagramElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class Node : public DiagramElement {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/DD/20100524/DI:Node"] = &createInstance<Node>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    Node(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_Node_H
#ifndef XML_bpmn_Label_H
#define XML_bpmn_Label_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class Bounds;
 
/**
 * Overview:
 * - Element name:  Label
 * - XML-Schema:    xsd/DI.xsd
 * - XML-Namespace: http://www.omg.org/spec/DD/20100524/DI
 *
 * Members:
 * - dc_Bounds : Bounds [0..*]
 * - extension : DiagramElement_extension [0..*] (from: DiagramElement)
 * - id : ID [0..1] (from: DiagramElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class Label : public Node {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/DD/20100524/DI:Label"] = &createInstance<Label>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    Label(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::vector< std::reference_wrapper<Bounds> > dc_Bounds;
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_Label_H
#ifndef XML_bpmn_BPMNLabel_H
#define XML_bpmn_BPMNLabel_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  BPMNLabel
 * - XML-Schema:    xsd/BPMNDI.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/DI
 *
 * Members:
 * - labelStyle : QName [0..1]
 * - dc_Bounds : Bounds [0..*] (from: Label)
 * - extension : DiagramElement_extension [0..*] (from: DiagramElement)
 * - id : ID [0..1] (from: DiagramElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class BPMNLabel : public Label {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/DI:BPMNLabel"] = &createInstance<BPMNLabel>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    BPMNLabel(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
    friend class BPMNEdge;
    friend class BPMNShape;
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::optional< std::reference_wrapper<Attribute> > labelStyle; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_BPMNLabel_H
#ifndef XML_bpmn_Plane_H
#define XML_bpmn_Plane_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class DiagramElement;
 
/**
 * Overview:
 * - Element name:  Plane
 * - XML-Schema:    xsd/DI.xsd
 * - XML-Namespace: http://www.omg.org/spec/DD/20100524/DI
 *
 * Members:
 * - di_DiagramElement : DiagramElement [0..*]
 * - extension : DiagramElement_extension [0..*] (from: DiagramElement)
 * - id : ID [0..1] (from: DiagramElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class Plane : public Node {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/DD/20100524/DI:Plane"] = &createInstance<Plane>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    Plane(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::vector< std::reference_wrapper<DiagramElement> > di_DiagramElement;
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_Plane_H
#ifndef XML_bpmn_BPMNPlane_H
#define XML_bpmn_BPMNPlane_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  BPMNPlane
 * - XML-Schema:    xsd/BPMNDI.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/DI
 *
 * Members:
 * - bpmnElement : QName [0..1]
 * - di_DiagramElement : DiagramElement [0..*] (from: Plane)
 * - extension : DiagramElement_extension [0..*] (from: DiagramElement)
 * - id : ID [0..1] (from: DiagramElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class BPMNPlane : public Plane {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/DI:BPMNPlane"] = &createInstance<BPMNPlane>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    BPMNPlane(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
    friend class BPMNDiagram;
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::optional< std::reference_wrapper<Attribute> > bpmnElement; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_BPMNPlane_H
#ifndef XML_bpmn_Shape_H
#define XML_bpmn_Shape_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class Bounds;
 
/**
 * Overview:
 * - Element name:  Shape
 * - XML-Schema:    xsd/DI.xsd
 * - XML-Namespace: http://www.omg.org/spec/DD/20100524/DI
 *
 * Members:
 * - dc_Bounds : Bounds [0..*]
 * - extension : DiagramElement_extension [0..*] (from: DiagramElement)
 * - id : ID [0..1] (from: DiagramElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class Shape : public Node {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/DD/20100524/DI:Shape"] = &createInstance<Shape>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    Shape(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::vector< std::reference_wrapper<Bounds> > dc_Bounds;
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_Shape_H
#ifndef XML_bpmn_LabeledShape_H
#define XML_bpmn_LabeledShape_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  LabeledShape
 * - XML-Schema:    xsd/DI.xsd
 * - XML-Namespace: http://www.omg.org/spec/DD/20100524/DI
 *
 * Members:
 * - dc_Bounds : Bounds [0..*] (from: Shape)
 * - extension : DiagramElement_extension [0..*] (from: DiagramElement)
 * - id : ID [0..1] (from: DiagramElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class LabeledShape : public Shape {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/DD/20100524/DI:LabeledShape"] = &createInstance<LabeledShape>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    LabeledShape(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_LabeledShape_H
#ifndef XML_bpmn_BPMNShape_H
#define XML_bpmn_BPMNShape_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class BPMNLabel;
class ParticipantBandKind;
 
/**
 * Overview:
 * - Element name:  BPMNShape
 * - XML-Schema:    xsd/BPMNDI.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/DI
 *
 * Members:
 * - bpmndi_BPMNLabel : BPMNLabel [0..*]
 * - bpmnElement : QName [0..1]
 * - isHorizontal : boolean [0..1]
 * - isExpanded : boolean [0..1]
 * - isMarkerVisible : boolean [0..1]
 * - isMessageVisible : boolean [0..1]
 * - participantBandKind : ParticipantBandKind [0..1]
 * - choreographyActivityShape : QName [0..1]
 * - dc_Bounds : Bounds [0..*] (from: Shape)
 * - extension : DiagramElement_extension [0..*] (from: DiagramElement)
 * - id : ID [0..1] (from: DiagramElement)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class BPMNShape : public LabeledShape {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/DI:BPMNShape"] = &createInstance<BPMNShape>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    BPMNShape(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::vector< std::reference_wrapper<BPMNLabel> > bpmndi_BPMNLabel;
    std::optional< std::reference_wrapper<Attribute> > bpmnElement; ///< Attribute value can be expected to be of type 'std::string'
    std::optional< std::reference_wrapper<Attribute> > isHorizontal; ///< Attribute value can be expected to be of type 'bool'
    std::optional< std::reference_wrapper<Attribute> > isExpanded; ///< Attribute value can be expected to be of type 'bool'
    std::optional< std::reference_wrapper<Attribute> > isMarkerVisible; ///< Attribute value can be expected to be of type 'bool'
    std::optional< std::reference_wrapper<Attribute> > isMessageVisible; ///< Attribute value can be expected to be of type 'bool'
    std::optional< std::reference_wrapper<Attribute> > participantBandKind; ///< Attribute value can be expected to be of type 'std::string'
    std::optional< std::reference_wrapper<Attribute> > choreographyActivityShape; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_BPMNShape_H
#ifndef XML_bpmn_Style_H
#define XML_bpmn_Style_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
/**
 * Overview:
 * - Element name:  Style
 * - XML-Schema:    xsd/DI.xsd
 * - XML-Namespace: http://www.omg.org/spec/DD/20100524/DI
 *
 * Members:
 * - id : ID [0..1]
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class Style : public XMLObject {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/DD/20100524/DI:Style"] = &createInstance<Style>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    Style(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::optional< std::reference_wrapper<Attribute> > id; ///< Attribute value can be expected to be of type 'std::string'
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_Style_H
#ifndef XML_bpmn_BPMNLabelStyle_H
#define XML_bpmn_BPMNLabelStyle_H
#include <memory>
#include <optional>
#include <vector>
 
 
/**
 * @brief The `XML::bpmn` namespace contains classes from the following XML-schema(s): @ref xsd/DC.xsd, @ref xsd/DI.xsd, @ref xsd/BPMNDI.xsd, @ref xsd/Semantic.xsd, @ref xsd/BPMN20.xsd.
 */
namespace XML::bpmn {
 
class Font;
 
/**
 * Overview:
 * - Element name:  BPMNLabelStyle
 * - XML-Schema:    xsd/BPMNDI.xsd
 * - XML-Namespace: http://www.omg.org/spec/BPMN/20100524/DI
 *
 * Members:
 * - dc_Font : Font [0..*]
 * - id : ID [0..1] (from: Style)
 *
 * Automatically generated by schematic++ v0.4.0 (https://github.com/rajgoel/schematicpp)
 */
class BPMNLabelStyle : public Style {
    template<typename T> friend XMLObject* ::XML::createInstance(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element);
private:
    static bool registerClass() {
        XMLObject::factory["http://www.omg.org/spec/BPMN/20100524/DI:BPMNLabelStyle"] = &createInstance<BPMNLabelStyle>; // register function in factory
        return true;
    };
    inline static bool registered = registerClass();
protected:
    BPMNLabelStyle(const Namespace& xmlns, const ClassName& className, const xercesc::DOMElement* element, const Attributes& defaultAttributes);
 
    friend class BPMNDiagram;
 
public:
    /// default attributes to be used if they are not explicitly provided
    inline static const Attributes defaults = {
    };
 
    std::vector< std::reference_wrapper<Font> > dc_Font;
};
 
} // namespace XML::bpmn
 
#endif // XML_bpmn_BPMNLabelStyle_H
#ifndef BPMN_Element_H
#define BPMN_Element_H
 
 
namespace BPMN {
 
/**
 * @brief Abstract base class for all elements in a BPMN model.
 *
 * The class provides conveniance methods to cast the element to concrete types.
 */
class Element {
public:
  virtual ~Element() = default;
 
  /**
   * @brief Attempts to cast the element to the specified type T.
   * @return A pointer to casted object or `nullptr` if the cast fails
   */
  template<typename T> T* represents() {
    return dynamic_cast<T*>(this);
  }
 
  /**
   * @brief Attempts to cast the element to the specified type T.
   * @return A pointer to casted object or `nullptr` if the cast fails
   */
  template<typename T> const T* represents() const {
    return dynamic_cast<const T*>(this);
  }
 
  /**
   * @brief Casts the element to the specified type T.
   * @return A pointer to casted object
   * @throws std::runtime_error if cast fails
   */
  template<typename T> T* as() {
    T* ptr = dynamic_cast<T*>(this);
    if ( ptr == nullptr ) {
      throw std::runtime_error("Element: Illegal cast of element");
    }
    return ptr;
  }
 
  /**
   * @brief Casts the element to the specified type  T.
   * @return A pointer to casted object
   * @throws std::runtime_error if cast fails
   */
  template<typename T> const T* as() const {
    const T* ptr = dynamic_cast<const T*>(this);
    if ( ptr == nullptr ) {
      throw std::runtime_error("Element: Illegal cast of element");
    }
    return ptr;
  }
};
 
} // namespace BPMN
 
#endif // BPMN_Element_H
#ifndef BPMN_BaseElement_H
#define BPMN_BaseElement_H
 
 
namespace BPMN {
 
class ExtensionElements;
/**
 * @brief Base class for all core BPMN elements.
 *
 * The class allows to access the underlying XML element and may have associated extension elements.
 */
class BaseElement : public Element {
public:
  /// @brief Constructs a BaseElement object representing a BPMN element.
  BaseElement(XML::bpmn::tBaseElement* element);
 
  XML::bpmn::tBaseElement* element;
 
  /// @brief Id of element.
  std::string id;
  std::unique_ptr<ExtensionElements> extensionElements;
 
  /**
   * @brief Attempts to return the @ref element in the specified type T.
   * @return A pointer to casted object or `nullptr` if the cast fails
   */
  template<typename T> T* is() {
    return dynamic_cast<T*>(element);
  }
 
  /**
   * @brief Attempts to return the @ref element in the specified type T.
   * @return A pointer to casted object or `nullptr` if the cast fails
   */
  template<typename T> const T* is() const {
    return dynamic_cast<const T*>(element);
  }
 
  /**
   * @brief Casts the @ref element to the specified type T.
   * @return A pointer to casted object
   * @throws std::runtime_error if the cast fails
   */
  template<typename T = XML::bpmn::tBaseElement> T* get() {
    T* ptr = dynamic_cast<T*>(element); 
    if ( ptr == nullptr ) {
      throw std::runtime_error("Element: Illegal cast of element '" + (element->id.has_value() ? (std::string)element->id->get().value : "") + "'");
    }
    return ptr;
  }
 
  /**
   * @brief Casts the element to the specified type T.
   * @return A pointer to casted object
   * @throws std::runtime_error if the cast fails
   */
  template<typename T = XML::bpmn::tBaseElement> const T* get() const {
    const T* ptr = dynamic_cast<const T*>(element);
    if ( ptr == nullptr ) {
      throw std::runtime_error("Element: Illegal cast of element" + ( element->id.has_value() ? " '" + (std::string)element->id->get().value + "'" : "" ) );
    }
    return ptr;
  }
};
 
} // namespace BPMN
 
#endif // BPMN_BaseElement_H
#ifndef BPMN_ExtensionElements_H
#define BPMN_ExtensionElements_H
 
 
namespace BPMN {
 
class BaseElement;
 
/**
 * @brief Base class for extension elements that may be provided for a BPMN element.
 */
class ExtensionElements : public Element {
public:
  ExtensionElements(XML::bpmn::tBaseElement* element);
 
  XML::bpmn::tExtensionElements* element;
 
  /**
   * @brief Returns a vector of elements of type T embedded within a container of type T.
   **/
  template<class C, class T> std::vector< std::reference_wrapper<T> > get() {
   if ( element ) {
       if ( auto container = element->template getOptionalChild<C>(); container.has_value() ) {
        return container->get().template getChildren<T>();
      }
    }
    return std::vector< std::reference_wrapper<T> >(); 
  }
 
  /**
   * @brief Returns a vector of elements of type T embedded within a container of type T.
   **/
  template<class C, class T> std::vector< std::reference_wrapper<const T> > get() const {
   if ( element ) {
       if ( auto container = element->template getOptionalChild<const C>(); container.has_value() ) {
        return container->get().template getChildren<const T>();
      }
    }
    return std::vector< std::reference_wrapper<const T> >(); 
  }
 
  /**
   * @brief Reference to the base element the extension elements are bound to.
   */
  BaseElement* baseElement;
private:
  /**
   * @brief Returns the @ref element if given or a `nullptr` otherwise.
   **/
  XML::bpmn::tExtensionElements* getExtensionElements(XML::bpmn::tBaseElement* element);
 
};
 
} // namespace BPMN
 
#endif // BPMN_ExtensionElements_H
#ifndef BPMN_DataObject_H
#define BPMN_DataObject_H
 
#include <memory>
#include <vector>
#include <optional>
 
namespace BPMN {
 
class DataObject : public BaseElement {
  friend class Model;
public:
  DataObject(XML::bpmn::tDataObject* dataObject);
  bool isCollection;
  XML::bpmn::tDataObject* element;
protected:
};
 
} // namespace BPMN
 
#endif // BPMN_DataObject_H
#ifndef BPMN_Node_H
#define BPMN_Node_H
 
#include <memory>
#include <vector>
#include <optional>
#include <functional>
 
namespace BPMN {
 
class Model;
class Scope;
 
class MessageFlow;
/**
 * @brief Base class for all nodes in a BPMN model.
 *
 * The Node class encapsulates the information and relationships associated with a node in a BPMN process.
 * It can represent both a BPMN process itself or a flow node within a process. 
 */
class Node : public BaseElement {
  friend class Model;
public:
  /// @brief Constructs a Node object representing a BPMN process or flow node.
  Node(XML::bpmn::tBaseElement* element);
 
  /// @brief Vector containing all message flows going in to the node.
  std::vector< MessageFlow* > receiving;
 
  /// @brief Vector containing all message flows going out of the node.
  std::vector< MessageFlow* > sending;
 
  /**
   * @brief Returns the first node found matching a given condition.
   *
   * @return A pointer to a node matching condition, or `nullptr` if no such node exists
   */
  Node* find(std::function<bool(Node*)> condition);
 
  /**
   * @brief Returns the first node found matching a given condition.
   *
   * @return A pointer to a node matching condition, or `nullptr` if no such node exists
   */
  const Node* find(std::function<bool(const Node*)> condition) const;
 
  /**
   * @brief Returns all nodes matching a given condition.
   *
   * @return A vector of pointers to nodes matching condition
   */
  std::vector< Node* > find_all(std::function<bool(Node*)> condition);
 
  /**
   * @brief Returns all nodes matching a given condition.
   *
   * @return A vector of pointers to nodes matching condition
   */
  std::vector< const Node* > find_all(std::function<bool(const Node*)> condition) const;
 
};
 
} // namespace BPMN
 
#endif // BPMN_Node_H
#ifndef BPMN_Scope_H
#define BPMN_Scope_H
 
#include <memory>
#include <vector>
#include <optional>
 
namespace BPMN {
 
class FlowNode;
class Activity;
class EventSubProcess;
class SequenceFlow;
 
/**
 * @brief Base class for BPMN elements that may contain a ChildNode elements.
 *
 * The Scope class provides functionalities to access child nodes,
 * event subprocesses, start nodes, and sequence flows associated 
 * with the scope.
 */
class Scope : virtual public Node {
  friend class Model;
public:
  Scope(XML::bpmn::tBaseElement* element);
 
  /// @brief Vector containing all child nodes within the scope of the nodes.
  std::vector< std::unique_ptr<Node> > childNodes;
 
  /// @brief Vector containing pointers to all flow nodes within the scope of the nodes.
  std::vector< FlowNode* > flowNodes;
 
  /// @brief Vector containing pointers to all event subprocesses within the scope of the nodes.
  std::vector< EventSubProcess* > eventSubProcesses;
 
  /// @brief Vector containing all flow nodes that may start execution of the scope.
  std::vector< FlowNode* > startNodes;
 
  /// @brief Vector containing all sequence flows within the scope.
  std::vector< std::unique_ptr<SequenceFlow> > sequenceFlows;
 
  /// @brief Vector containing pointers to all compensation activities within the scope.
  std::vector< Activity* > compensationActivities;
 
  /// @brief Pointer to compensation event subprocess of the scope.
  EventSubProcess* compensationEventSubProcess;
 
  /// @brief Vector containing all data objects within the scope.
  std::vector< std::unique_ptr<DataObject> > dataObjects;
 
protected:
  void add(std::unique_ptr<Node> node);
  void add(std::unique_ptr<SequenceFlow> sequenceFlow);
  void add(std::unique_ptr<DataObject> dataObject);
};
 
} // namespace BPMN
 
#endif // BPMN_Scope_H
#ifndef BPMN_ChildNode_H
#define BPMN_ChildNode_H
 
#include <memory>
#include <vector>
#include <optional>
 
namespace BPMN {
 
class SequenceFlow;
 
/**
 * @brief Base class for BPMN elements within a Scope.
 */
class ChildNode : virtual public Node {
  friend class Model;
public:
  ChildNode(XML::bpmn::tBaseElement* element, Scope* parent);
 
  /// @brief Reference to the parent node.
  Scope* parent;
};
 
} // namespace BPMN
 
#endif // BPMN_ChildNode_H
#ifndef BPMN_Process_H
#define BPMN_Process_H
 
#include <memory>
#include <vector>
#include <optional>
 
namespace BPMN {
 
class Process : public Scope {
  friend class Model;
public:
  Process(XML::bpmn::tProcess* process);
  bool isExecutable;
  XML::bpmn::tProcess* element;
protected:
};
 
} // namespace BPMN
 
#endif // BPMN_Process_H
#ifndef BPMN_EventSubProcess_H
#define BPMN_EventSubProcess_H
 
#include <memory>
#include <vector>
#include <optional>
 
namespace BPMN {
 
class TypedStartEvent;
 
class EventSubProcess : public ChildNode, public Scope  {
  friend class Model;
public:
  EventSubProcess(XML::bpmn::tSubProcess* subProcess, Scope* parent);
  TypedStartEvent* startEvent;
  XML::bpmn::tSubProcess* element;
};
 
} // namespace BPMN
 
#endif // BPMN_EventSubProcess_H
#ifndef BPMN_SequenceFlow_H
#define BPMN_SequenceFlow_H
 
 
namespace BPMN {
 
class Scope;
class FlowNode;
 
/**
 * @brief The SequenceFlow class encapsulates the information and relationships associated with a sequence flow
 * in a BPMN process.
 *
 * The class provides access to the underlying @ref XML::bpmn::tSequenceFlow element
 * and the source and target node.
 */
class SequenceFlow : public BaseElement {
public:
  //// @brief Constructs a SequenceFlow object based on a @ref XML::bpmn::tSequenceFlow element and the parent scope.
  SequenceFlow(XML::bpmn::tSequenceFlow* sequenceFlow, Scope* scope);
 
  XML::bpmn::tSequenceFlow* element;
 
  /// @brief Reference to the source node of the sequence flow.
  FlowNode* source;
  /// @brief Reference to the target node of the sequence flow.
  FlowNode* target;
 
protected:
  FlowNode* findNode(std::string& id, Scope* scope);
};
 
} // namespace BPMN
 
#endif // BPMN_SequenceFlow_H
 
#ifndef BPMN_FlowNode_H
#define BPMN_FlowNode_H
 
#include <memory>
#include <vector>
#include <optional>
 
namespace BPMN {
 
class SequenceFlow;
 
/**
 * @brief Base class for BPMN elements that may contain incoming and outgoing sequence flows.
 *
 * The FlowNode class encapsulates the information and relationships associated with a node in a BPMN process.
 * The class provides  allows to access the parent scope as well as incoming and outgoing sequence flows.
 */
class FlowNode : public ChildNode {
  friend class Model;
public:
  XML::bpmn::tFlowNode* element;
  FlowNode(XML::bpmn::tFlowNode* flowNode, Scope* parent);
 
  std::optional<std::string> name;
  
  /// @brief Vector containing all incoming sequence flows of the node.
  std::vector< SequenceFlow* > incoming;
 
  /// @brief Vector containing all outgoing sequence flows of the node.
  std::vector< SequenceFlow* > outgoing;
 
protected:
};
 
} // namespace BPMN
 
#endif // BPMN_FlowNode_H
#ifndef BPMN_Event_H
#define BPMN_Event_H
 
#include <memory>
#include <vector>
#include <optional>
 
namespace BPMN {
 
/**
 * @attention Multiple event definitions are not yet supported.
 **/
class Event : virtual public FlowNode {
  friend class Model;
public:
  Event(XML::bpmn::tEvent* event, Scope* parent);
  XML::bpmn::tEvent* element;
};
 
} // namespace BPMN
 
#endif // BPMN_Event_H
#ifndef BPMN_CatchEvent_H
#define BPMN_CatchEvent_H
 
#include <memory>
#include <vector>
#include <optional>
 
namespace BPMN {
 
class CatchEvent : public Event {
  friend class Model;
public:
  CatchEvent(XML::bpmn::tCatchEvent* catchEvent, Scope* parent);
  XML::bpmn::tCatchEvent* element;
};
 
} // namespace BPMN
 
#endif // BPMN_CatchEvent_H
#ifndef BPMN_ConditionalCatchEvent_H
#define BPMN_ConditionalCatchEvent_H
 
#include <memory>
#include <vector>
#include <optional>
 
namespace BPMN {
 
class ConditionalCatchEvent : virtual public CatchEvent {
  friend class Model;
public:
  ConditionalCatchEvent(XML::bpmn::tCatchEvent* catchEvent, Scope* parent);
};
 
} // namespace BPMN
 
#endif // BPMN_ConditionalCatchEvent_H
#ifndef BPMN_MessageCatchEvent_H
#define BPMN_MessageCatchEvent_H
 
#include <memory>
#include <vector>
#include <optional>
 
namespace BPMN {
 
class MessageCatchEvent : virtual public CatchEvent {
  friend class Model;
public:
  MessageCatchEvent(XML::bpmn::tCatchEvent* catchEvent, Scope* parent);
};
 
} // namespace BPMN
 
#endif // BPMN_MessageCatchEvent_H
#ifndef BPMN_SignalCatchEvent_H
#define BPMN_SignalCatchEvent_H
 
#include <memory>
#include <vector>
#include <optional>
 
namespace BPMN {
 
class SignalCatchEvent : virtual public CatchEvent {
  friend class Model;
public:
  SignalCatchEvent(XML::bpmn::tCatchEvent* catchEvent, Scope* parent);
};
 
} // namespace BPMN
 
#endif // BPMN_SignalCatchEvent_H
#ifndef BPMN_TimerCatchEvent_H
#define BPMN_TimerCatchEvent_H
 
#include <memory>
#include <vector>
#include <optional>
 
namespace BPMN {
 
class TimerCatchEvent : virtual public CatchEvent {
  friend class Model;
public:
  TimerCatchEvent(XML::bpmn::tCatchEvent* catchEvent, Scope* parent);
};
 
} // namespace BPMN
 
#endif // BPMN_TimerCatchEvent_H
#ifndef BPMN_LinkTargetEvent_H
#define BPMN_LinkTargetEvent_H
 
#include <memory>
#include <vector>
#include <optional>
 
namespace BPMN {
 
/**
 * @attention If no `linkName` is given, it is set to `name` attribute if this is given.
 * The sources are determined based on the `linkName`.
 */
class LinkTargetEvent : virtual public CatchEvent {
  friend class Model;
public:
  LinkTargetEvent(XML::bpmn::tCatchEvent* catchEvent, Scope* parent);
  std::string linkName;
  std::vector<FlowNode*> sources;
};
 
} // namespace BPMN
 
#endif // BPMN_LinkTargetEvent_H
#ifndef BPMN_UntypedStartEvent_H
#define BPMN_UntypedStartEvent_H
 
#include <memory>
#include <vector>
#include <optional>
 
namespace BPMN {
 
class UntypedStartEvent : virtual public CatchEvent {
  friend class Model;
public:
  UntypedStartEvent(XML::bpmn::tCatchEvent* catchEvent, Scope* parent);
};
 
} // namespace BPMN
 
#endif // BPMN_UntypedStartEvent_H
#ifndef BPMN_TypedStartEvent_H
#define BPMN_TypedStartEvent_H
 
 
namespace BPMN {
 
class Activity;
 
/**
 * @brief Base class for all start events with an event definition.
 */
class TypedStartEvent : virtual public CatchEvent {
  friend class Model;
public:
  TypedStartEvent(XML::bpmn::tStartEvent* startEvent, Scope* parent);
  bool isInterrupting;
};
 
} // namespace BPMN
 
#endif // BPMN_TypedStartEvent_H
#ifndef BPMN_CompensateStartEvent_H
#define BPMN_CompensateStartEvent_H
 
#include <memory>
#include <vector>
#include <optional>
 
namespace BPMN {
 
class CompensateStartEvent : public TypedStartEvent {
  friend class Model;
public:
  CompensateStartEvent(XML::bpmn::tStartEvent* startEvent, Scope* parent);
};
 
} // namespace BPMN
 
#endif // BPMN_CompensateStartEvent_H
#ifndef BPMN_ErrorStartEvent_H
#define BPMN_ErrorStartEvent_H
 
#include <memory>
#include <vector>
#include <optional>
 
namespace BPMN {
 
class ErrorStartEvent : public TypedStartEvent {
  friend class Model;
public:
  ErrorStartEvent(XML::bpmn::tStartEvent* startEvent, Scope* parent);
};
 
} // namespace BPMN
 
#endif // BPMN_ErrorStartEvent_H
#ifndef BPMN_EscalationStartEvent_H
#define BPMN_EscalationStartEvent_H
 
#include <memory>
#include <vector>
#include <optional>
 
namespace BPMN {
 
class EscalationStartEvent : public TypedStartEvent {
  friend class Model;
public:
  EscalationStartEvent(XML::bpmn::tStartEvent* startEvent, Scope* parent);
};
 
} // namespace BPMN
 
#endif // BPMN_EscalationStartEvent_H
#ifndef BPMN_ConditionalStartEvent_H
#define BPMN_ConditionalStartEvent_H
 
#include <memory>
#include <vector>
#include <optional>
 
namespace BPMN {
 
class ConditionalStartEvent : public ConditionalCatchEvent, public TypedStartEvent {
  friend class Model;
public:
  ConditionalStartEvent(XML::bpmn::tStartEvent* startEvent, Scope* parent);
  XML::bpmn::tStartEvent* element;
};
 
} // namespace BPMN
 
#endif // BPMN_ConditionalStartEvent_H
#ifndef BPMN_MessageStartEvent_H
#define BPMN_MessageStartEvent_H
 
#include <memory>
#include <vector>
#include <optional>
 
namespace BPMN {
 
class MessageStartEvent : public MessageCatchEvent, public TypedStartEvent {
  friend class Model;
public:
  MessageStartEvent(XML::bpmn::tStartEvent* startEvent, Scope* parent);
  XML::bpmn::tStartEvent* element;
};
 
} // namespace BPMN
 
#endif // BPMN_MessageStartEvent_H
#ifndef BPMN_SignalStartEvent_H
#define BPMN_SignalStartEvent_H
 
#include <memory>
#include <vector>
#include <optional>
 
namespace BPMN {
 
class SignalStartEvent : public SignalCatchEvent, public TypedStartEvent {
  friend class Model;
public:
  SignalStartEvent(XML::bpmn::tStartEvent* startEvent, Scope* parent);
  XML::bpmn::tStartEvent* element;
};
 
} // namespace BPMN
 
#endif // BPMN_SignalStartEvent_H
#ifndef BPMN_TimerStartEvent_H
#define BPMN_TimerStartEvent_H
 
#include <memory>
#include <vector>
#include <optional>
 
namespace BPMN {
 
class TimerStartEvent : public TimerCatchEvent, public TypedStartEvent {
  friend class Model;
public:
  TimerStartEvent(XML::bpmn::tStartEvent* startEvent, Scope* parent);
  XML::bpmn::tStartEvent* element;
};
 
} // namespace BPMN
 
#endif // BPMN_TimerStartEvent_H
#ifndef BPMN_ThrowEvent_H
#define BPMN_ThrowEvent_H
 
#include <memory>
#include <vector>
#include <optional>
 
namespace BPMN {
 
class ThrowEvent : public Event {
  friend class Model;
public:
  ThrowEvent(XML::bpmn::tThrowEvent* throwEvent, Scope* parent);
 
  XML::bpmn::tThrowEvent* element;
protected:
};
 
} // namespace BPMN
 
#endif // BPMN_ThrowEvent_H
#ifndef BPMN_UntypedEndEvent_H
#define BPMN_UntypedEndEvent_H
 
#include <memory>
#include <vector>
#include <optional>
 
namespace BPMN {
 
class UntypedEndEvent : public ThrowEvent {
  friend class Model;
public:
  UntypedEndEvent(XML::bpmn::tThrowEvent* throwEvent, Scope* parent);
};
 
} // namespace BPMN
 
#endif // BPMN_UntypedEndEvent_H
#ifndef BPMN_CancelEndEvent_H
#define BPMN_CancelEndEvent_H
 
#include <memory>
#include <vector>
#include <optional>
 
namespace BPMN {
 
class CancelEndEvent : public ThrowEvent {
  friend class Model;
public:
  CancelEndEvent(XML::bpmn::tThrowEvent* throwEvent, Scope* parent);
};
 
} // namespace BPMN
 
#endif // BPMN_CancelEndEvent_H
#ifndef BPMN_CompensateThrowEvent_H
#define BPMN_CompensateThrowEvent_H
 
#include <memory>
#include <vector>
#include <optional>
 
namespace BPMN {
 
/**
 * @note If @ref activity is `nullptr` then each completed Activity in relevant Scope has to be compensated.
 **/
class CompensateThrowEvent : public ThrowEvent {
  friend class Model;
public:
  CompensateThrowEvent(XML::bpmn::tThrowEvent* throwEvent, Scope* parent);
  Activity* activity; ///< Activity to be compensated
};
 
} // namespace BPMN
 
#endif // BPMN_CompensateThrowEvent_H
#ifndef BPMN_ErrorEndEvent_H
#define BPMN_ErrorEndEvent_H
 
#include <memory>
#include <vector>
#include <optional>
 
namespace BPMN {
 
class ErrorEndEvent : public ThrowEvent {
  friend class Model;
public:
  ErrorEndEvent(XML::bpmn::tThrowEvent* throwEvent, Scope* parent);
};
 
} // namespace BPMN
 
#endif // BPMN_ErrorEndEvent_H
#ifndef BPMN_EscalationThrowEvent_H
#define BPMN_EscalationThrowEvent_H
 
#include <memory>
#include <vector>
#include <optional>
 
namespace BPMN {
 
class EscalationThrowEvent : public ThrowEvent {
  friend class Model;
public:
  EscalationThrowEvent(XML::bpmn::tThrowEvent* throwEvent, Scope* parent);
};
 
} // namespace BPMN
 
#endif // BPMN_EscalationThrowEvent_H
#ifndef BPMN_MessageThrowEvent_H
#define BPMN_MessageThrowEvent_H
 
#include <memory>
#include <vector>
#include <optional>
 
namespace BPMN {
 
class MessageThrowEvent : public ThrowEvent {
  friend class Model;
public:
  MessageThrowEvent(XML::bpmn::tThrowEvent* throwEvent, Scope* parent);
};
 
} // namespace BPMN
 
#endif // BPMN_MessageThrowEvent_H
#ifndef BPMN_SignalThrowEvent_H
#define BPMN_SignalThrowEvent_H
 
#include <memory>
#include <vector>
#include <optional>
 
namespace BPMN {
 
class SignalThrowEvent : public ThrowEvent {
  friend class Model;
public:
  SignalThrowEvent(XML::bpmn::tThrowEvent* throwEvent, Scope* parent);
};
 
} // namespace BPMN
 
#endif // BPMN_SignalThrowEvent_H
#ifndef BPMN_TerminateEvent_H
#define BPMN_TerminateEvent_H
 
#include <memory>
#include <vector>
#include <optional>
 
namespace BPMN {
 
class TerminateEvent : public ThrowEvent {
  friend class Model;
public:
  TerminateEvent(XML::bpmn::tThrowEvent* throwEvent, Scope* parent);
};
 
} // namespace BPMN
 
#endif // BPMN_TerminateEvent_H
#ifndef BPMN_LinkSourceEvent_H
#define BPMN_LinkSourceEvent_H
 
#include <memory>
#include <vector>
#include <optional>
 
namespace BPMN {
 
/**
 * @attention If no `linkName` is given, it is set to `name` attribute if this is given.
 * The target is determined based on the `linkName`.
 */
class LinkSourceEvent : public ThrowEvent {
  friend class Model;
public:
  LinkSourceEvent(XML::bpmn::tThrowEvent* throwEvent, Scope* parent);
  std::string linkName;
  FlowNode* target; 
};
 
} // namespace BPMN
 
#endif // BPMN_LinkSourceEvent_H
#ifndef BPMN_BoundaryEvent_H
#define BPMN_BoundaryEvent_H
 
 
namespace BPMN {
 
class Activity;
 
/**
 * @brief Base class for all boundary events attached to an Activity.
 */
class BoundaryEvent : virtual public CatchEvent {
  friend class Model;
public:
  BoundaryEvent(XML::bpmn::tBoundaryEvent* boundaryEvent, Scope* parent);
  bool isInterrupting;
  Activity* attachedTo;
protected:
  Activity* resolveReference();
};
 
} // namespace BPMN
 
#endif // BPMN_BoundaryEvent_H
#ifndef BPMN_CancelBoundaryEvent_H
#define BPMN_CancelBoundaryEvent_H
 
#include <memory>
#include <vector>
#include <optional>
 
namespace BPMN {
 
class CancelBoundaryEvent : virtual public BoundaryEvent, virtual public CatchEvent {
  friend class Model;
public:
  CancelBoundaryEvent(XML::bpmn::tBoundaryEvent* boundaryEvent, Scope* parent);
  XML::bpmn::tBoundaryEvent* element;
};
 
} // namespace BPMN
 
#endif // BPMN_CancelBoundaryEvent_H
#ifndef BPMN_CompensateBoundaryEvent_H
#define BPMN_CompensateBoundaryEvent_H
 
#include <memory>
#include <vector>
#include <optional>
 
namespace BPMN {
 
class CompensateBoundaryEvent : virtual public BoundaryEvent, virtual public CatchEvent {
  friend class Model;
public:
  CompensateBoundaryEvent(XML::bpmn::tBoundaryEvent* boundaryEvent, Scope* parent);
  XML::bpmn::tBoundaryEvent* element;
};
 
} // namespace BPMN
 
#endif // BPMN_CompensateBoundaryEvent_H
#ifndef BPMN_ConditionalBoundaryEvent_H
#define BPMN_ConditionalBoundaryEvent_H
 
#include <memory>
#include <vector>
#include <optional>
 
namespace BPMN {
 
class ConditionalBoundaryEvent : public ConditionalCatchEvent, public BoundaryEvent {
  friend class Model;
public:
  ConditionalBoundaryEvent(XML::bpmn::tBoundaryEvent* boundaryEvent, Scope* parent);
  XML::bpmn::tBoundaryEvent* element;
};
 
} // namespace BPMN
 
#endif // BPMN_ConditionalBoundaryEvent_H
#ifndef BPMN_ErrorBoundaryEvent_H
#define BPMN_ErrorBoundaryEvent_H
 
#include <memory>
#include <vector>
#include <optional>
 
namespace BPMN {
 
class ErrorBoundaryEvent : virtual public BoundaryEvent, virtual public CatchEvent {
  friend class Model;
public:
  ErrorBoundaryEvent(XML::bpmn::tBoundaryEvent* boundaryEvent, Scope* parent);
  XML::bpmn::tBoundaryEvent* element;
};
 
} // namespace BPMN
 
#endif // BPMN_ErrorBoundaryEvent_H
#ifndef BPMN_EscalationBoundaryEvent_H
#define BPMN_EscalationBoundaryEvent_H
 
#include <memory>
#include <vector>
#include <optional>
 
namespace BPMN {
 
class EscalationBoundaryEvent : virtual public BoundaryEvent, virtual public CatchEvent {
  friend class Model;
public:
  EscalationBoundaryEvent(XML::bpmn::tBoundaryEvent* boundaryEvent, Scope* parent);
  XML::bpmn::tBoundaryEvent* element;
};
 
} // namespace BPMN
 
#endif // BPMN_EscalationBoundaryEvent_H
#ifndef BPMN_MessageBoundaryEvent_H
#define BPMN_MessageBoundaryEvent_H
 
#include <memory>
#include <vector>
#include <optional>
 
namespace BPMN {
 
class MessageBoundaryEvent : public MessageCatchEvent, public BoundaryEvent {
  friend class Model;
public:
  MessageBoundaryEvent(XML::bpmn::tBoundaryEvent* boundaryEvent, Scope* parent);
  XML::bpmn::tBoundaryEvent* element;
};
 
} // namespace BPMN
 
#endif // BPMN_MessageBoundaryEvent_H
#ifndef BPMN_SignalBoundaryEvent_H
#define BPMN_SignalBoundaryEvent_H
 
#include <memory>
#include <vector>
#include <optional>
 
namespace BPMN {
 
class SignalBoundaryEvent : public SignalCatchEvent, public BoundaryEvent {
  friend class Model;
public:
  SignalBoundaryEvent(XML::bpmn::tBoundaryEvent* boundaryEvent, Scope* parent);
  XML::bpmn::tBoundaryEvent* element;
};
 
} // namespace BPMN
 
#endif // BPMN_SignalBoundaryEvent_H
#ifndef BPMN_TimerBoundaryEvent_H
#define BPMN_TimerBoundaryEvent_H
 
#include <memory>
#include <vector>
#include <optional>
 
namespace BPMN {
 
class TimerBoundaryEvent : public TimerCatchEvent, public BoundaryEvent {
  friend class Model;
public:
  TimerBoundaryEvent(XML::bpmn::tBoundaryEvent* boundaryEvent, Scope* parent);
 
  XML::bpmn::tBoundaryEvent* element;
protected:
};
 
} // namespace BPMN
 
#endif // BPMN_TimerBoundaryEvent_H
#ifndef BPMN_Activity_H
#define BPMN_Activity_H
 
#include <memory>
#include <vector>
#include <optional>
 
namespace BPMN {
 
class BoundaryEvent;
 
class Activity : virtual public FlowNode {
  friend class Model;
public:
  Activity(XML::bpmn::tActivity* activity, Scope* parent);
 
  std::vector< BoundaryEvent* > boundaryEvents;
  Node* compensatedBy; ///< Pointer to compensation activity or compensation event sub-process
  bool isForCompensation;
  enum class LoopCharacteristics { Standard, MultiInstanceSequential, MultiInstanceParallel };
  std::optional<LoopCharacteristics> loopCharacteristics;
 
  XML::bpmn::tActivity* element;
};
 
} // namespace BPMN
 
#endif // BPMN_Activity_H
#ifndef BPMN_SubProcess_H
#define BPMN_SubProcess_H
 
#include <memory>
#include <vector>
#include <optional>
 
namespace BPMN {
 
class UntypedStartEvent;
 
class SubProcess : public Activity, public Scope {
  friend class Model;
public:
  SubProcess(XML::bpmn::tSubProcess* subProcess, Scope* parent);
  UntypedStartEvent* startEvent;
  XML::bpmn::tSubProcess* element;
protected:
};
 
} // namespace BPMN
 
#endif // BPMN_SubProcess_H
#ifndef BPMN_Task_H
#define BPMN_Task_H
 
#include <memory>
#include <vector>
#include <optional>
 
namespace BPMN {
 
class Task : public Activity {
  friend class Model;
public:
  Task(XML::bpmn::tTask* task, Scope* parent);
 
  XML::bpmn::tTask* element;
protected:
};
 
} // namespace BPMN
 
#endif // BPMN_Task_H
#ifndef BPMN_AbstractTask_H
#define BPMN_AbstractTask_H
 
#include <memory>
#include <vector>
#include <optional>
 
namespace BPMN {
 
class AbstractTask : public Task {
  friend class Model;
public:
  AbstractTask(XML::bpmn::tTask* task, Scope* parent);
};
 
} // namespace BPMN
 
#endif // BPMN_AbstractTask_H
#ifndef BPMN_BusinessRuleTask_H
#define BPMN_BusinessRuleTask_H
 
#include <memory>
#include <vector>
#include <optional>
 
namespace BPMN {
 
class BusinessRuleTask : public Task {
  friend class Model;
public:
  BusinessRuleTask(XML::bpmn::tBusinessRuleTask* businessRuleTask, Scope* parent);
 
  XML::bpmn::tBusinessRuleTask* element;
protected:
};
 
} // namespace BPMN
 
#endif // BPMN_BusinessRuleTask_H
#ifndef BPMN_ManualTask_H
#define BPMN_ManualTask_H
 
#include <memory>
#include <vector>
#include <optional>
 
namespace BPMN {
 
class ManualTask : public Task {
  friend class Model;
public:
  ManualTask(XML::bpmn::tManualTask* manualTask, Scope* parent);
 
  XML::bpmn::tManualTask* element;
protected:
};
 
} // namespace BPMN
 
#endif // BPMN_ManualTask_H
#ifndef BPMN_ReceiveTask_H
#define BPMN_ReceiveTask_H
 
#include <memory>
#include <vector>
#include <optional>
 
namespace BPMN {
 
class ReceiveTask : public Task, public MessageCatchEvent {
  friend class Model;
public:
  ReceiveTask(XML::bpmn::tReceiveTask* receiveTask, Scope* parent);
 
  XML::bpmn::tReceiveTask* element;
protected:
};
 
} // namespace BPMN
 
#endif // BPMN_ReceiveTask_H
#ifndef BPMN_ScriptTask_H
#define BPMN_ScriptTask_H
 
#include <memory>
#include <vector>
#include <optional>
 
namespace BPMN {
 
class ScriptTask : public Task {
  friend class Model;
public:
  ScriptTask(XML::bpmn::tScriptTask* scriptTask, Scope* parent);
 
  XML::bpmn::tScriptTask* element;
protected:
};
 
} // namespace BPMN
 
#endif // BPMN_ScriptTask_H
#ifndef BPMN_SendTask_H
#define BPMN_SendTask_H
 
#include <memory>
#include <vector>
#include <optional>
 
namespace BPMN {
 
class SendTask : public Task, public MessageThrowEvent {
  friend class Model;
public:
  SendTask(XML::bpmn::tSendTask* sendTask, Scope* parent);
 
  XML::bpmn::tSendTask* element;
protected:
};
 
} // namespace BPMN
 
#endif // BPMN_SendTask_H
#ifndef BPMN_UserTask_H
#define BPMN_UserTask_H
 
#include <memory>
#include <vector>
#include <optional>
 
namespace BPMN {
 
class UserTask : public Task {
  friend class Model;
public:
  UserTask(XML::bpmn::tUserTask* userTask, Scope* parent);
 
  XML::bpmn::tUserTask* element;
protected:
};
 
} // namespace BPMN
 
#endif // BPMN_UserTask_H
#ifndef BPMN_CallActivity_H
#define BPMN_CallActivity_H
 
#include <memory>
#include <vector>
#include <optional>
 
namespace BPMN {
 
class CallActivity : public Activity {
  friend class Model;
public:
  CallActivity(XML::bpmn::tCallActivity* callActivity, Scope* parent);
 
  XML::bpmn::tCallActivity* element;
protected:
};
 
} // namespace BPMN
 
#endif // BPMN_CallActivity_H
#ifndef BPMN_AdHocSubProcess_H
#define BPMN_AdHocSubProcess_H
 
#include <memory>
#include <vector>
#include <optional>
 
namespace BPMN {
 
class AdHocSubProcess : public Activity, public Scope {
  friend class Model;
public:
  AdHocSubProcess(XML::bpmn::tAdHocSubProcess* adHocSubProcess, Scope* parent);
  bool isSequential;
  XML::bpmn::tAdHocSubProcess* element;
};
 
} // namespace BPMN
 
#endif // BPMN_AdHocSubProcess_H
#ifndef BPMN_Transaction_H
#define BPMN_Transaction_H
 
#include <memory>
#include <vector>
#include <optional>
 
namespace BPMN {
 
class Transaction : public SubProcess {
  friend class Model;
public:
  Transaction(XML::bpmn::tTransaction* transaction, Scope* parent);
 
  XML::bpmn::tTransaction* element;
protected:
};
 
} // namespace BPMN
 
#endif // BPMN_Transaction_H
#ifndef BPMN_Gateway_H
#define BPMN_Gateway_H
 
#include <memory>
#include <vector>
#include <optional>
 
namespace BPMN {
 
class Gateway : public FlowNode {
  friend class Model;
public:
  Gateway(XML::bpmn::tGateway* gateway, Scope* parent);
 
  XML::bpmn::tGateway* element;
protected:
};
 
} // namespace BPMN
 
#endif // BPMN_Gateway_H
#ifndef BPMN_ParallelGateway_H
#define BPMN_ParallelGateway_H
 
#include <memory>
#include <vector>
#include <optional>
 
namespace BPMN {
 
class ParallelGateway : public Gateway {
  friend class Model;
public:
  ParallelGateway(XML::bpmn::tParallelGateway* parallelGateway, Scope* parent);
 
  XML::bpmn::tParallelGateway* element;
protected:
};
 
} // namespace BPMN
 
#endif // BPMN_ParallelGateway_H
#ifndef BPMN_ExclusiveGateway_H
#define BPMN_ExclusiveGateway_H
 
#include <memory>
#include <vector>
#include <optional>
 
namespace BPMN {
 
class ExclusiveGateway : public Gateway {
  friend class Model;
public:
  ExclusiveGateway(XML::bpmn::tExclusiveGateway* exclusiveGateway, Scope* parent);
 
  XML::bpmn::tExclusiveGateway* element;
  SequenceFlow* defaultFlow;
protected:
};
 
} // namespace BPMN
 
#endif // BPMN_ExclusiveGateway_H
#ifndef BPMN_InclusiveGateway_H
#define BPMN_InclusiveGateway_H
 
#include <memory>
#include <vector>
#include <optional>
 
namespace BPMN {
 
class InclusiveGateway : public Gateway {
  friend class Model;
public:
  InclusiveGateway(XML::bpmn::tInclusiveGateway* inclusiveGateway, Scope* parent);
 
  XML::bpmn::tInclusiveGateway* element;
  SequenceFlow* defaultFlow;
protected:
};
 
} // namespace BPMN
 
#endif // BPMN_InclusiveGateway_H
#ifndef BPMN_ComplexGateway_H
#define BPMN_ComplexGateway_H
 
#include <memory>
#include <vector>
#include <optional>
 
namespace BPMN {
 
class ComplexGateway : public Gateway {
  friend class Model;
public:
  ComplexGateway(XML::bpmn::tComplexGateway* complexGateway, Scope* parent);
 
  XML::bpmn::tComplexGateway* element;
  SequenceFlow* defaultFlow;
protected:
};
 
} // namespace BPMN
 
#endif // BPMN_ComplexGateway_H
#ifndef BPMN_EventBasedGateway_H
#define BPMN_EventBasedGateway_H
 
#include <memory>
#include <vector>
#include <optional>
 
namespace BPMN {
 
class EventBasedGateway : public Gateway {
  friend class Model;
public:
  EventBasedGateway(XML::bpmn::tEventBasedGateway* eventBasedGateway, Scope* parent);
 
  XML::bpmn::tEventBasedGateway* element;
protected:
};
 
} // namespace BPMN
 
#endif // BPMN_EventBasedGateway_H
#ifndef BPMN_MessageFlow_H
#define BPMN_MessageFlow_H
 
 
namespace BPMN {
 
class Model;
class Process;
class Scope;
class FlowNode;
 
/**
 * @brief The MessageFlow class encapsulates the information and relationships associated with
 * a message flow in a BPMN process.
 *
 * The class provides access to the underlying @ref XML::bpmn::tMessageFlow element and the source
 * and target node.
 */
class MessageFlow : public BaseElement {
public:
  /// @brief Constructs a MessageFlow object based on a @ref XML::bpmn::tMessageFlow element.
  MessageFlow(XML::bpmn::tMessageFlow* messageFlow);
 
  XML::bpmn::tMessageFlow* element;
 
  /// @brief Reference to the source node of the message flow.
  std::pair<Process*, FlowNode*> source;
  /// @brief Reference to the target node of the message flow.
  std::pair<Process*, FlowNode*> target;
protected:
  friend class Model;
  void initialize(std::vector< std::unique_ptr<Process> >& processes, std::unordered_map<std::string,std::string>& participantMap);
  FlowNode* findRecursive(std::string& id, Scope* scope);
};
 
} // namespace BPMN
 
#endif // BPMN_MessageFlow_H
 
#ifndef BPMN_Model_H
#define BPMN_Model_H
 
#include <memory>
#include <vector>
#include <string>
 
/**
 * @brief The `BPMN` namespace contains linked classes representing a BPMN model.
 *
 * For each supported BPMN element a wrapper is used that contains an `element`
 * attribute which is a pointer to the raw representation of the respective element
 * in the BPMN file according to the XML-schema.
 * @see XML::bpmn
 */
namespace BPMN {
 
class Node;
class SequenceFlow;
class MessageFlow;
 
 
/**
 * @brief Represents a BPMN model with all its processes and message flows.
 *
 * The Model class reads a BPMN model from a file and provides access to all processes
 * with their content as well as to all message flows in a BPMN model.
 * @see @ref Process, @ref MessageFlow
 * @note The BPMN model is expected to conform with the BPMN specification, e.g.,
 * it is expected that all boundary events and start events of event subprocesses have
 * an event definition.
 * @par
 * @note All nodes in a process model are derived from an abstract class @ref Node. The
 * class model uses multiple inheritance to provide type specific attributes. References
 * are usually provided by pointers to a base class. Casting is required to gain access
 * to type specific attributes.
 * @par
 * @note The BPMN extension mechanism can be used by providing a custom model class derived
 * from @ref Model and a custom extension derived from the abstract base class
 * @ref ExtensionElements. The following example shows how an object of the custom extension
 * `MyExtensionElements` class can be bound to processes by overriding the method
 * @ref Model::createProcess in the custom model `MyModel` class:
 * ```
 * std::unique_ptr<BPMN::Process> MyModel::createProcess(XML::bpmn::tProcess* process) {
 *   return bind<BPMN::Process>(
 *     BPMN::Model::createProcess(process),
 *     std::make_unique<MyExtensionElements>(process)
 *   );
 * }
 * ```
 *
 * @warning Multiple event definitions are not yet supported. A `std::runtime_error`
 * will be thrown when parsing an event with multiple event definitions.
 *
 * References between different classes are automatically determined:
 * - For each sequence flow and each message flow, pointers to the source and target
 *   are provided.
 *   @see @ref SequenceFlow, @ref MessageFlow, @ref FlowNode, @ref Process
 *
 * - For each node, pointers to receiving and sending message flows are provided.
 *   @see Node
 * - For each BPMN element that may have child nodes within its scope, the child nodes
 *   and sequence flows between them are owned by the node. Pointers to each flow node,
 *   event subprocess,  start events, compensation activities, and compensation event
 *   subprocess are given.
 *   @see @ref Scope
 * - For each node within a scope, a pointer to the parent scope is provided.
 *   @see @ref ChildNode
 * - For each node that may receive a flow token, pointers to all incoming and outgoing
 *   sequence flows are given.
 *   @see @ref FlowNode, @ref SequenceFlow
 * - For each subprocess, a pointer to the start event is provided.
 *   @attention It is expected that each subprocess has a unique @ref UntypedStartEvent.
 *   @see @ref SubProcess
 * - For each event subprocess, a pointer to the start event is provided.
 *   @attention It is expected that each event subprocess has a unique @ref TypedStartEvent.
 *   @see @ref EventSubProcess
 * - For each activity, pointers to each boundary event (excluding the compensation
 *   boundary event) are provided.
 *   @see @ref Activity, @ref BoundaryEvent
 * - For each activity that can be compensated, a pointer to the compensation activity
 *   or compensation event subprocess is provided.
 *   @attention Activities must not have both compensation activity and compensation event
 *              subprocess.
 *   @see @ref Activity, @ref CompensateBoundaryEvent, @ref CompensateStartEvent
 * - For each event attached to the boundary of an activity, a pointer to the activity
 *   is provided.
 *   @see @ref Activity, @ref BoundaryEvent
 * - For each link event, a pointer to the respective target or source(s) is provided.
 *   @note Target and sources are matched based on the
 *         @ref XML::bpmn::tLinkEventDefinition::name attribute in the link event
 *         definition. If no such name is given, the @ref FlowNode::name attribute of the link
 *         event is used as fallback.
 *   @attention For each link source exactly one link target must be found, otherwise a
 *              `std::runtime_error` will be thrown.
 *   @see @ref LinkSourceEvent, @ref LinkTargetEvent, @ref XML::bpmn::tLinkEventDefinition,
 *        @ref  FlowNode
 * - For each throwing compensation event, a pointer to the activity to be compensated is
 *   provided.
 *   @note The respective activity is determined based on the
 *         @ref XML::bpmn::tCompensateEventDefinition::activityRef attribute of the
 *         compensation event definition and the @ref Node::id attribute of the activity. If
 *         no such attribute reference is given, respective activity is determined based on the 
 *         @ref FlowNode::name attribute of the compensate throw event and the @ref FlowNode::name
 *         of the activity.
 *   @attention Compensation throw events in compensation event subprocesses can only trigger
 *              compensation of activities within parent scope. All other compensation throw events can
 *              only trigger compensation of activities within the same scope.
 *   @see @ref CompensateThrowEvent, @ref XML::bpmn::tCompensateEventDefinition, @ref Activity,
 *        @ref  FlowNode
 **/
class Model {
protected:
    Model() {};
public:
  Model(const std::string& filename);
  virtual ~Model() = default;
  std::vector< std::unique_ptr<XML::XMLObject> > roots;
  std::vector< std::unique_ptr<Process> > processes;
  std::vector< std::unique_ptr<MessageFlow> > messageFlows;
protected:
  virtual void readBPMNFile(const std::string& filename);
  virtual std::unique_ptr<XML::XMLObject> createRoot(const std::string& filename);
 
  virtual std::unique_ptr<Process> createProcess(XML::bpmn::tProcess* process);
  virtual std::unique_ptr<EventSubProcess> createEventSubProcess(XML::bpmn::tSubProcess* subProcess, Scope* parent);
  virtual std::unique_ptr<FlowNode> createFlowNode(XML::bpmn::tFlowNode* flowNode, Scope* parent);
 
  virtual std::unique_ptr<FlowNode> createActivity(XML::bpmn::tActivity* activity, Scope* parent);
 
  virtual std::unique_ptr<FlowNode> createSubProcess(XML::bpmn::tSubProcess* subProcess, Scope* parent);
  virtual std::unique_ptr<FlowNode> createCallActivity(XML::bpmn::tCallActivity* callActivity, Scope* parent);
  virtual std::unique_ptr<FlowNode> createAdHocSubProcess(XML::bpmn::tAdHocSubProcess* adHocSubProcess, Scope* parent);
  virtual std::unique_ptr<FlowNode> createTransaction(XML::bpmn::tTransaction* transaction, Scope* parent);
  virtual std::unique_ptr<FlowNode> createTask(XML::bpmn::tTask* task, Scope* parent);
 
  virtual std::unique_ptr<FlowNode> createAbstractTask(XML::bpmn::tTask* task, Scope* parent);
  virtual std::unique_ptr<FlowNode> createSendTask(XML::bpmn::tSendTask* sendTask, Scope* parent);
  virtual std::unique_ptr<FlowNode> createReceiveTask(XML::bpmn::tReceiveTask* receiveTask, Scope* parent);
  virtual std::unique_ptr<FlowNode> createUserTask(XML::bpmn::tUserTask* userTask, Scope* parent);
  virtual std::unique_ptr<FlowNode> createManualTask(XML::bpmn::tManualTask* manualTask, Scope* parent);
  virtual std::unique_ptr<FlowNode> createScriptTask(XML::bpmn::tScriptTask* scriptTask, Scope* parent);
  virtual std::unique_ptr<FlowNode> createBusinessRuleTask(XML::bpmn::tBusinessRuleTask* businessRuleTask, Scope* parent);
 
  virtual std::unique_ptr<FlowNode> createEvent(XML::bpmn::tEvent* event, Scope* parent);
 
  virtual std::unique_ptr<FlowNode> createBoundaryEvent(XML::bpmn::tBoundaryEvent* boundaryEvent, Scope* parent);
  virtual std::unique_ptr<FlowNode> createCancelBoundaryEvent(XML::bpmn::tBoundaryEvent* boundaryEvent, Scope* parent);
  virtual std::unique_ptr<FlowNode> createCompensateBoundaryEvent(XML::bpmn::tBoundaryEvent* boundaryEvent, Scope* parent);
  virtual std::unique_ptr<FlowNode> createConditionalBoundaryEvent(XML::bpmn::tBoundaryEvent* boundaryEvent, Scope* parent);
  virtual std::unique_ptr<FlowNode> createErrorBoundaryEvent(XML::bpmn::tBoundaryEvent* boundaryEvent, Scope* parent);
  virtual std::unique_ptr<FlowNode> createEscalationBoundaryEvent(XML::bpmn::tBoundaryEvent* boundaryEvent, Scope* parent);
  virtual std::unique_ptr<FlowNode> createMessageBoundaryEvent(XML::bpmn::tBoundaryEvent* boundaryEvent, Scope* parent);
  virtual std::unique_ptr<FlowNode> createSignalBoundaryEvent(XML::bpmn::tBoundaryEvent* boundaryEvent, Scope* parent);
  virtual std::unique_ptr<FlowNode> createTimerBoundaryEvent(XML::bpmn::tBoundaryEvent* boundaryEvent, Scope* parent);
 
  virtual std::unique_ptr<FlowNode> createCatchEvent(XML::bpmn::tCatchEvent* catchEvent, Scope* parent);
 
  virtual std::unique_ptr<FlowNode> createConditionalCatchEvent(XML::bpmn::tCatchEvent* catchEvent, Scope* parent);
  virtual std::unique_ptr<FlowNode> createMessageCatchEvent(XML::bpmn::tCatchEvent* catchEvent, Scope* parent);
  virtual std::unique_ptr<FlowNode> createSignalCatchEvent(XML::bpmn::tCatchEvent* catchEvent, Scope* parent);
  virtual std::unique_ptr<FlowNode> createTimerCatchEvent(XML::bpmn::tCatchEvent* catchEvent, Scope* parent);
  virtual std::unique_ptr<FlowNode> createLinkTargetEvent(XML::bpmn::tCatchEvent* catchEvent, Scope* parent);
 
  virtual std::unique_ptr<FlowNode> createTypedStartEvent(XML::bpmn::tStartEvent* startEvent, XML::bpmn::tEventDefinition& eventDefinition, Scope* parent);
 
  virtual std::unique_ptr<FlowNode> createCompensateStartEvent(XML::bpmn::tStartEvent* startEvent, Scope* parent);
  virtual std::unique_ptr<FlowNode> createErrorStartEvent(XML::bpmn::tStartEvent* startEvent, Scope* parent);
  virtual std::unique_ptr<FlowNode> createEscalationStartEvent(XML::bpmn::tStartEvent* startEvent, Scope* parent);
  virtual std::unique_ptr<FlowNode> createConditionalStartEvent(XML::bpmn::tStartEvent* startEvent, Scope* parent);
  virtual std::unique_ptr<FlowNode> createMessageStartEvent(XML::bpmn::tStartEvent* startEvent, Scope* parent);
  virtual std::unique_ptr<FlowNode> createSignalStartEvent(XML::bpmn::tStartEvent* startEvent, Scope* parent);
  virtual std::unique_ptr<FlowNode> createTimerStartEvent(XML::bpmn::tStartEvent* startEvent, Scope* parent);
 
  virtual std::unique_ptr<FlowNode> createUntypedStartEvent(XML::bpmn::tCatchEvent* catchEvent, Scope* parent);
 
  virtual std::unique_ptr<FlowNode> createThrowEvent(XML::bpmn::tThrowEvent* throwEvent, Scope* parent);
  virtual std::unique_ptr<FlowNode> createCancelEndEvent(XML::bpmn::tThrowEvent* throwEvent, Scope* parent);
  virtual std::unique_ptr<FlowNode> createCompensateThrowEvent(XML::bpmn::tThrowEvent* throwEvent, Scope* parent);
  virtual std::unique_ptr<FlowNode> createErrorEndEvent(XML::bpmn::tThrowEvent* throwEvent, Scope* parent);
  virtual std::unique_ptr<FlowNode> createEscalationThrowEvent(XML::bpmn::tThrowEvent* throwEvent, Scope* parent);
  virtual std::unique_ptr<FlowNode> createMessageThrowEvent(XML::bpmn::tThrowEvent* throwEvent, Scope* parent);
  virtual std::unique_ptr<FlowNode> createSignalThrowEvent(XML::bpmn::tThrowEvent* throwEvent, Scope* parent);
  virtual std::unique_ptr<FlowNode> createTerminateEvent(XML::bpmn::tThrowEvent* throwEvent, Scope* parent);
  virtual std::unique_ptr<FlowNode> createLinkSourceEvent(XML::bpmn::tThrowEvent* throwEvent, Scope* parent);
  virtual std::unique_ptr<FlowNode> createUntypedEndEvent(XML::bpmn::tThrowEvent* throwEvent, Scope* parent);
  virtual std::unique_ptr<FlowNode> createGateway(XML::bpmn::tGateway* gateway, Scope* parent);
 
  virtual std::unique_ptr<FlowNode> createParallelGateway(XML::bpmn::tParallelGateway* parallelGateway, Scope* parent);
  virtual std::unique_ptr<FlowNode> createExclusiveGateway(XML::bpmn::tExclusiveGateway* exclusiveGateway, Scope* parent);
  virtual std::unique_ptr<FlowNode> createInclusiveGateway(XML::bpmn::tInclusiveGateway* inclusiveGateway, Scope* parent);
  virtual std::unique_ptr<FlowNode> createEventBasedGateway(XML::bpmn::tEventBasedGateway* eventBasedGateway, Scope* parent);
  virtual std::unique_ptr<FlowNode> createComplexGateway(XML::bpmn::tComplexGateway* complexGateway, Scope* parent);
 
  virtual std::unique_ptr<SequenceFlow> createSequenceFlow(XML::bpmn::tSequenceFlow* sequenceFlow, Scope* scope);
  virtual std::unique_ptr<DataObject> createDataObject(XML::bpmn::tDataObject* dataObject, BPMN::Scope* scope);
  virtual std::unique_ptr<MessageFlow> createMessageFlow(XML::bpmn::tMessageFlow* messageFlow);
 
  virtual void createChildNodes(Scope* scope);
  virtual void createSequenceFlows(Scope* scope);
  virtual void createNestedReferences(Scope* scope);
  virtual void createFlowReferences(FlowNode* flowNode);
  virtual void createCompensations(Scope* scope);
  virtual void createCompensationReferences(Scope* scope);
  virtual void createLinks(Scope* scope);
  virtual void createMessageFlows();
 
  /// Binds the extension elements to the given baseElement
  template< typename T>
  static std::unique_ptr<T> bind(std::unique_ptr<T>&& baseElement, std::unique_ptr<ExtensionElements>&& extensionElements) {
    baseElement->extensionElements = std::move(extensionElements);
    baseElement->extensionElements->baseElement = baseElement.get();
    return std::move(baseElement);
  }
 
  /// Binds the extension elements to the given baseElement
  template< typename T>
  static std::unique_ptr<T> bind(std::unique_ptr<T>& baseElement, std::unique_ptr<ExtensionElements>& extensionElements) {
    baseElement->extensionElements = std::move(extensionElements);
    baseElement->extensionElements->baseElement = baseElement.get();
    return std::move(baseElement);
  }
 
  /// Binds the extension elements to the given baseElement
  template< typename T>
  static std::unique_ptr<T> bind(std::unique_ptr<T>& baseElement, std::unique_ptr<ExtensionElements>&& extensionElements) {
    baseElement->extensionElements = std::move(extensionElements);
    baseElement->extensionElements->baseElement = baseElement.get();
    return std::move(baseElement);
  }
 
  /// Binds the extension elements to the given baseElement
  template< typename T>
  static std::unique_ptr<T> bind(std::unique_ptr<T>&& baseElement, std::unique_ptr<ExtensionElements>& extensionElements) {
    baseElement->extensionElements = std::move(extensionElements);
    baseElement->extensionElements->baseElement = baseElement.get();
    return std::move(baseElement);
  }
 
 
 
};
 
} // namespace BPMN
 
#endif // BPMN_Model_H