// file : xsd/cxx/tree/types.hxx // author : Boris Kolpackov // copyright : Copyright (c) 2005-2009 Code Synthesis Tools CC // license : GNU GPL v2 + exceptions; see accompanying LICENSE file /** * @file * * @brief Contains C++ class definitions for XML Schema built-in types. * * This is an internal header and is included by the generated code. You * normally should not include it directly. * */ #ifndef XSD_CXX_TREE_TYPES_HXX #define XSD_CXX_TREE_TYPES_HXX #include #include // std::size_t #include #include #include #include #include #include #include namespace xsd { namespace cxx { /** * @brief C++/Tree mapping runtime namespace. * * This is an internal namespace and normally should not be referenced * directly. Instead you should use the aliases for types in this * namespaces that are created in the generated code. * */ namespace tree { /** * @brief Class corresponding to the XML Schema %string built-in * type. * * The %string class publicly inherits from and has the same set * of constructors as @c std::basic_string. It therefore can be * used as @c std::string (or @c std::wstring if you are using * @c wchar_t as the character type). * * @nosubgrouping */ template class string: public B, public std::basic_string { typedef std::basic_string base_type; base_type& base () { return *this; } public: /** * @name Constructors */ //@{ /** * @brief Default constructor creates an empty %string. */ string () { } /** * @brief Initialize an instance with a copy of a C %string. * * @param s A C %string to copy. */ string (const C* s) : base_type (s) { } /** * @brief Initialize an instance with a character array. * * @param s A character array to copy. * @param n A number of character to copy. */ string (const C* s, std::size_t n) : base_type (s, n) { } /** * @brief Initialize an instance with multiple copies of the same * character. * * @param n A number of copies to create. * @param c A character to copy. */ string (std::size_t n, C c) : base_type (n, c) { } /** * @brief Initialize an instance with a copy of a standard %string. * * @param s A standard %string to copy. */ string (const std::basic_string& s) : base_type (s) { } /** * @brief Initialize an instance with a copy of a substring. * * @param s A standard %string to copy the substring from. * @param pos An index of the first character to copy from. * @param n A number of characters to copy. */ string (const std::basic_string& s, std::size_t pos, std::size_t n = std::basic_string::npos) : base_type (s, pos, n) { } public: /** * @brief Copy constructor. * * @param x An instance to make a copy of. * @param f Flags to create the copy with. * @param c A pointer to the object that will contain the copy. * * For polymorphic object models use the @c _clone function instead. */ string (const string& x, flags f = 0, container* c = 0) : B (x, f, c), base_type (x) { } /** * @brief Copy the instance polymorphically. * * @param f Flags to create the copy with. * @param c A pointer to the object that will contain the copy. * @return A pointer to the dynamically allocated copy. * * This function ensures that the dynamic type of the instance * is used for copying and should be used for polymorphic object * models instead of the copy constructor. */ virtual string* _clone (flags f = 0, container* c = 0) const; public: /** * @brief Create an instance from a data representation * stream. * * @param s A stream to extract the data from. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ template string (istream& s, flags f = 0, container* c = 0); /** * @brief Create an instance from a DOM element. * * @param e A DOM element to extract the data from. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ string (const xercesc::DOMElement& e, flags f = 0, container* c = 0); /** * @brief Create an instance from a DOM Attribute. * * @param a A DOM attribute to extract the data from. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ string (const xercesc::DOMAttr& a, flags f = 0, container* c = 0); /** * @brief Create an instance from a %string fragment. * * @param s A %string fragment to extract the data from. * @param e A pointer to DOM element containing the %string fragment. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ string (const std::basic_string& s, const xercesc::DOMElement* e, flags f = 0, container* c = 0); //@} public: /** * @brief Assign a character to the instance. * * The resulting %string has only one character. * * @param c A character to assign. * @return A reference to the instance. */ string& operator= (C c) { base () = c; return *this; } /** * @brief Assign a C %string to the instance. * * The resulting %string contains a copy of the C %string. * * @param s A C %string to assign. * @return A reference to the instance. */ string& operator= (const C* s) { base () = s; return *this; } /** * @brief Assign a standard %string to the instance. * * The resulting %string contains a copy of the standard %string. * * @param s A standard %string to assign. * @return A reference to the instance. */ string& operator= (const std::basic_string& s) { base () = s; return *this; } /** * @brief Copy assignment operator. * * @param x An instance to assign. * @return A reference to the instance. */ string& operator= (const string& x) { base () = x; return *this; } }; /** * @brief Class corresponding to the XML Schema normalizedString * built-in type. * * The %normalized_string class publicly inherits from and has * the same set of constructors as @c std::basic_string. It * therefore can be used as @c std::string (or @c std::wstring * if you are using @c wchar_t as the character type). * * @nosubgrouping */ template class normalized_string: public B { typedef B base_type; base_type& base () { return *this; } public: /** * @name Constructors */ //@{ /** * @brief Default constructor creates an empty %normalized_string. */ normalized_string () { } /** * @brief Initialize an instance with a copy of a C %string. * * @param s A C %string to copy. */ normalized_string (const C* s) : base_type (s) { } /** * @brief Initialize an instance with a character array. * * @param s A character array to copy. * @param n A number of character to copy. */ normalized_string (const C* s, std::size_t n) : base_type (s, n) { } /** * @brief Initialize an instance with multiple copies of the same * character. * * @param n A number of copies to create. * @param c A character to copy. */ normalized_string (std::size_t n, C c) : base_type (n, c) { } /** * @brief Initialize an instance with a copy of a standard %string. * * @param s A standard %string to copy. */ normalized_string (const std::basic_string& s) : base_type (s) { } /** * @brief Initialize an instance with a copy of a substring. * * @param s A standard %string to copy the substring from. * @param pos An index of the first character to copy from. * @param n A number of characters to copy. */ normalized_string (const std::basic_string& s, std::size_t pos, std::size_t n = std::basic_string::npos) : base_type (s, pos, n) { } public: /** * @brief Copy constructor. * * @param x An instance to make a copy of. * @param f Flags to create the copy with. * @param c A pointer to the object that will contain the copy. * * For polymorphic object models use the @c _clone function instead. */ normalized_string (const normalized_string& x, flags f = 0, container* c = 0) : base_type (x, f, c) { } /** * @brief Copy the instance polymorphically. * * @param f Flags to create the copy with. * @param c A pointer to the object that will contain the copy. * @return A pointer to the dynamically allocated copy. * * This function ensures that the dynamic type of the instance * is used for copying and should be used for polymorphic object * models instead of the copy constructor. */ virtual normalized_string* _clone (flags f = 0, container* c = 0) const; public: /** * @brief Create an instance from a data representation * stream. * * @param s A stream to extract the data from. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ template normalized_string (istream& s, flags f = 0, container* c = 0); /** * @brief Create an instance from a DOM element. * * @param e A DOM element to extract the data from. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ normalized_string (const xercesc::DOMElement& e, flags f = 0, container* c = 0); /** * @brief Create an instance from a DOM Attribute. * * @param a A DOM attribute to extract the data from. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ normalized_string (const xercesc::DOMAttr& a, flags f = 0, container* c = 0); /** * @brief Create an instance from a %string fragment. * * @param s A %string fragment to extract the data from. * @param e A pointer to DOM element containing the %string fragment. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ normalized_string (const std::basic_string& s, const xercesc::DOMElement* e, flags f = 0, container* c = 0); //@} public: /** * @brief Assign a character to the instance. * * The resulting %normalized_string has only one character. * * @param c A character to assign. * @return A reference to the instance. */ normalized_string& operator= (C c) { base () = c; return *this; } /** * @brief Assign a C %string to the instance. * * The resulting %normalized_string contains a copy of the C %string. * * @param s A C %string to assign. * @return A reference to the instance. */ normalized_string& operator= (const C* s) { base () = s; return *this; } /** * @brief Assign a standard %string to the instance. * * The resulting %normalized_string contains a copy of the standard * %string. * * @param s A standard %string to assign. * @return A reference to the instance. */ normalized_string& operator= (const std::basic_string& s) { base () = s; return *this; } /** * @brief Copy assignment operator. * * @param x An instance to assign. * @return A reference to the instance. */ normalized_string& operator= (const normalized_string& x) { base () = x; return *this; } protected: //@cond void normalize (); //@endcond }; /** * @brief Class corresponding to the XML Schema %token built-in * type. * * The %token class publicly inherits from and has the same set * of constructors as @c std::basic_string. It therefore can be * used as @c std::string (or @c std::wstring if you are using * @c wchar_t as the character type). * * @nosubgrouping */ template class token: public B { typedef B base_type; base_type& base () { return *this; } public: /** * @name Constructors */ //@{ /** * @brief Default constructor creates an empty %token. */ token () { } /** * @brief Initialize an instance with a copy of a C %string. * * @param s A C %string to copy. */ token (const C* s) : base_type (s) { } /** * @brief Initialize an instance with a character array. * * @param s A character array to copy. * @param n A number of character to copy. */ token (const C* s, std::size_t n) : base_type (s, n) { } /** * @brief Initialize an instance with multiple copies of the same * character. * * @param n A number of copies to create. * @param c A character to copy. */ token (std::size_t n, C c) : base_type (n, c) { } /** * @brief Initialize an instance with a copy of a standard %string. * * @param s A standard %string to copy. */ token (const std::basic_string& s) : base_type (s) { } /** * @brief Initialize an instance with a copy of a substring. * * @param s A standard %string to copy the substring from. * @param pos An index of the first character to copy from. * @param n A number of characters to copy. */ token (const std::basic_string& s, std::size_t pos, std::size_t n = std::basic_string::npos) : base_type (s, pos, n) { } public: /** * @brief Copy constructor. * * @param x An instance to make a copy of. * @param f Flags to create the copy with. * @param c A pointer to the object that will contain the copy. * * For polymorphic object models use the @c _clone function instead. */ token (const token& x, flags f = 0, container* c = 0) : base_type (x, f, c) { } /** * @brief Copy the instance polymorphically. * * @param f Flags to create the copy with. * @param c A pointer to the object that will contain the copy. * @return A pointer to the dynamically allocated copy. * * This function ensures that the dynamic type of the instance * is used for copying and should be used for polymorphic object * models instead of the copy constructor. */ virtual token* _clone (flags f = 0, container* c = 0) const; public: /** * @brief Create an instance from a data representation * stream. * * @param s A stream to extract the data from. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ template token (istream& s, flags f = 0, container* c = 0); /** * @brief Create an instance from a DOM element. * * @param e A DOM element to extract the data from. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ token (const xercesc::DOMElement& e, flags f = 0, container* c = 0); /** * @brief Create an instance from a DOM Attribute. * * @param a A DOM attribute to extract the data from. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ token (const xercesc::DOMAttr& a, flags f = 0, container* c = 0); /** * @brief Create an instance from a %string fragment. * * @param s A %string fragment to extract the data from. * @param e A pointer to DOM element containing the %string fragment. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ token (const std::basic_string& s, const xercesc::DOMElement* e, flags f = 0, container* c = 0); //@} public: /** * @brief Assign a character to the instance. * * The resulting %token has only one character. * * @param c A character to assign. * @return A reference to the instance. */ token& operator= (C c) { base () = c; return *this; } /** * @brief Assign a C %string to the instance. * * The resulting %token contains a copy of the C %string. * * @param s A C %string to assign. * @return A reference to the instance. */ token& operator= (const C* s) { base () = s; return *this; } /** * @brief Assign a standard %string to the instance. * * The resulting %token contains a copy of the standard %string. * * @param s A standard %string to assign. * @return A reference to the instance. */ token& operator= (const std::basic_string& s) { base () = s; return *this; } /** * @brief Copy assignment operator. * * @param x An instance to assign. * @return A reference to the instance. */ token& operator= (const token& x) { base () = x; return *this; } protected: //@cond void collapse (); //@endcond }; /** * @brief Class corresponding to the XML Schema NMTOKEN built-in * type. * * The %nmtoken class publicly inherits from and has the same set * of constructors as @c std::basic_string. It therefore can be * used as @c std::string (or @c std::wstring if you are using * @c wchar_t as the character type). * * @nosubgrouping */ template class nmtoken: public B { typedef B base_type; base_type& base () { return *this; } public: /** * @name Constructors */ //@{ /** * @brief Initialize an instance with a copy of a C %string. * * @param s A C %string to copy. */ nmtoken (const C* s) : base_type (s) { } /** * @brief Initialize an instance with a character array. * * @param s A character array to copy. * @param n A number of character to copy. */ nmtoken (const C* s, std::size_t n) : base_type (s, n) { } /** * @brief Initialize an instance with multiple copies of the same * character. * * @param n A number of copies to create. * @param c A character to copy. */ nmtoken (std::size_t n, C c) : base_type (n, c) { } /** * @brief Initialize an instance with a copy of a standard %string. * * @param s A standard %string to copy. */ nmtoken (const std::basic_string& s) : base_type (s) { } /** * @brief Initialize an instance with a copy of a substring. * * @param s A standard %string to copy the substring from. * @param pos An index of the first character to copy from. * @param n A number of characters to copy. */ nmtoken (const std::basic_string& s, std::size_t pos, std::size_t n = std::basic_string::npos) : base_type (s, pos, n) { } public: /** * @brief Copy constructor. * * @param x An instance to make a copy of. * @param f Flags to create the copy with. * @param c A pointer to the object that will contain the copy. * * For polymorphic object models use the @c _clone function instead. */ nmtoken (const nmtoken& x, flags f = 0, container* c = 0) : base_type (x, f, c) { } /** * @brief Copy the instance polymorphically. * * @param f Flags to create the copy with. * @param c A pointer to the object that will contain the copy. * @return A pointer to the dynamically allocated copy. * * This function ensures that the dynamic type of the instance * is used for copying and should be used for polymorphic object * models instead of the copy constructor. */ virtual nmtoken* _clone (flags f = 0, container* c = 0) const; public: /** * @brief Create an instance from a data representation * stream. * * @param s A stream to extract the data from. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ template nmtoken (istream& s, flags f = 0, container* c = 0); /** * @brief Create an instance from a DOM element. * * @param e A DOM element to extract the data from. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ nmtoken (const xercesc::DOMElement& e, flags f = 0, container* c = 0); /** * @brief Create an instance from a DOM Attribute. * * @param a A DOM attribute to extract the data from. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ nmtoken (const xercesc::DOMAttr& a, flags f = 0, container* c = 0); /** * @brief Create an instance from a %string fragment. * * @param s A %string fragment to extract the data from. * @param e A pointer to DOM element containing the %string fragment. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ nmtoken (const std::basic_string& s, const xercesc::DOMElement* e, flags f = 0, container* c = 0); //@} public: /** * @brief Assign a character to the instance. * * The resulting %nmtoken has only one character. * * @param c A character to assign. * @return A reference to the instance. */ nmtoken& operator= (C c) { base () = c; return *this; } /** * @brief Assign a C %string to the instance. * * The resulting %nmtoken contains a copy of the C %string. * * @param s A C %string to assign. * @return A reference to the instance. */ nmtoken& operator= (const C* s) { base () = s; return *this; } /** * @brief Assign a standard %string to the instance. * * The resulting %nmtoken contains a copy of the standard %string. * * @param s A standard %string to assign. * @return A reference to the instance. */ nmtoken& operator= (const std::basic_string& s) { base () = s; return *this; } /** * @brief Copy assignment operator. * * @param x An instance to assign. * @return A reference to the instance. */ nmtoken& operator= (const nmtoken& x) { base () = x; return *this; } protected: //@cond nmtoken () : base_type () { } //@endcond }; /** * @brief Class corresponding to the XML Schema NMTOKENS built-in * type. * * The %nmtokens class is a vector (or %list in XML Schema terminology) * of nmtoken elements. It is implemented in terms of the list class * template. * * @nosubgrouping */ template class nmtokens: public B, public list { typedef list base_type; public: /** * @name Constructors */ //@{ /** * @brief Default constructor creates no elements. */ nmtokens () : base_type (0, this) { } /** * @brief Initialize the instance with copies of an exemplar elements. * * @param n A number of elements to copy. * @param x An exemplar element to copy. */ nmtokens (typename base_type::size_type n, const nmtoken& x) : base_type (n, x, this) { } /** * @brief Initialize the instance with copies of elements from an * iterator range. * * @param begin An iterator pointing to the first element. * @param end An iterator pointing to the one past the last element. */ template nmtokens (const I& begin, const I& end) : base_type (begin, end, this) { } public: /** * @brief Copy constructor. * * @param x An instance to make a copy of. * @param f Flags to create the copy with. * @param c A pointer to the object that will contain the copy. * * For polymorphic object models use the @c _clone function instead. */ nmtokens (const nmtokens& x, flags f, container* c = 0) : B (x, f, c), base_type (x, f, this) { } /** * @brief Copy the instance polymorphically. * * @param f Flags to create the copy with. * @param c A pointer to the object that will contain the copy. * @return A pointer to the dynamically allocated copy. * * This function ensures that the dynamic type of the instance * is used for copying and should be used for polymorphic object * models instead of the copy constructor. */ virtual nmtokens* _clone (flags f = 0, container* c = 0) const; public: /** * @brief Create an instance from a data representation * stream. * * @param s A stream to extract the data from. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ template nmtokens (istream& s, flags f = 0, container* c = 0); /** * @brief Create an instance from a DOM element. * * @param e A DOM element to extract the data from. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ nmtokens (const xercesc::DOMElement& e, flags f = 0, container* c = 0); /** * @brief Create an instance from a DOM Attribute. * * @param a A DOM attribute to extract the data from. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ nmtokens (const xercesc::DOMAttr& a, flags f = 0, container* c = 0); /** * @brief Create an instance from a %string fragment. * * @param s A %string fragment to extract the data from. * @param e A pointer to DOM element containing the %string fragment. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ nmtokens (const std::basic_string& s, const xercesc::DOMElement* e, flags f = 0, container* c = 0); //@} }; /** * @brief Class corresponding to the XML Schema Name built-in * type. * * The %name class publicly inherits from and has the same set * of constructors as @c std::basic_string. It therefore can be * used as @c std::string (or @c std::wstring if you are using * @c wchar_t as the character type). * * @nosubgrouping */ template class name: public B { typedef B base_type; base_type& base () { return *this; } public: /** * @name Constructors */ //@{ /** * @brief Initialize an instance with a copy of a C %string. * * @param s A C %string to copy. */ name (const C* s) : base_type (s) { } /** * @brief Initialize an instance with a character array. * * @param s A character array to copy. * @param n A number of character to copy. */ name (const C* s, std::size_t n) : base_type (s, n) { } /** * @brief Initialize an instance with multiple copies of the same * character. * * @param n A number of copies to create. * @param c A character to copy. */ name (std::size_t n, C c) : base_type (n, c) { } /** * @brief Initialize an instance with a copy of a standard %string. * * @param s A standard %string to copy. */ name (const std::basic_string& s) : base_type (s) { } /** * @brief Initialize an instance with a copy of a substring. * * @param s A standard %string to copy the substring from. * @param pos An index of the first character to copy from. * @param n A number of characters to copy. */ name (const std::basic_string& s, std::size_t pos, std::size_t n = std::basic_string::npos) : base_type (s, pos, n) { } public: /** * @brief Copy constructor. * * @param x An instance to make a copy of. * @param f Flags to create the copy with. * @param c A pointer to the object that will contain the copy. * * For polymorphic object models use the @c _clone function instead. */ name (const name& x, flags f = 0, container* c = 0) : base_type (x, f, c) { } /** * @brief Copy the instance polymorphically. * * @param f Flags to create the copy with. * @param c A pointer to the object that will contain the copy. * @return A pointer to the dynamically allocated copy. * * This function ensures that the dynamic type of the instance * is used for copying and should be used for polymorphic object * models instead of the copy constructor. */ virtual name* _clone (flags f = 0, container* c = 0) const; public: /** * @brief Create an instance from a data representation * stream. * * @param s A stream to extract the data from. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ template name (istream& s, flags f = 0, container* c = 0); /** * @brief Create an instance from a DOM element. * * @param e A DOM element to extract the data from. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ name (const xercesc::DOMElement& e, flags f = 0, container* c = 0); /** * @brief Create an instance from a DOM Attribute. * * @param a A DOM attribute to extract the data from. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ name (const xercesc::DOMAttr& a, flags f = 0, container* c = 0); /** * @brief Create an instance from a %string fragment. * * @param s A %string fragment to extract the data from. * @param e A pointer to DOM element containing the %string fragment. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ name (const std::basic_string& s, const xercesc::DOMElement* e, flags f = 0, container* c = 0); //@} public: /** * @brief Assign a character to the instance. * * The resulting %name has only one character. * * @param c A character to assign. * @return A reference to the instance. */ name& operator= (C c) { base () = c; return *this; } /** * @brief Assign a C %string to the instance. * * The resulting %name contains a copy of the C %string. * * @param s A C %string to assign. * @return A reference to the instance. */ name& operator= (const C* s) { base () = s; return *this; } /** * @brief Assign a standard %string to the instance. * * The resulting %name contains a copy of the standard %string. * * @param s A standard %string to assign. * @return A reference to the instance. */ name& operator= (const std::basic_string& s) { base () = s; return *this; } /** * @brief Copy assignment operator. * * @param x An instance to assign. * @return A reference to the instance. */ name& operator= (const name& x) { base () = x; return *this; } protected: //@cond name () : base_type () { } //@endcond }; // Forward declaration for Sun CC. // template class qname; /** * @brief Class corresponding to the XML Schema NCame built-in * type. * * The %ncname class publicly inherits from and has the same set * of constructors as @c std::basic_string. It therefore can be * used as @c std::string (or @c std::wstring if you are using * @c wchar_t as the character type). * * @nosubgrouping */ template class ncname: public B { typedef B base_type; base_type& base () { return *this; } public: /** * @name Constructors */ //@{ /** * @brief Initialize an instance with a copy of a C %string. * * @param s A C %string to copy. */ ncname (const C* s) : base_type (s) { } /** * @brief Initialize an instance with a character array. * * @param s A character array to copy. * @param n A number of character to copy. */ ncname (const C* s, std::size_t n) : base_type (s, n) { } /** * @brief Initialize an instance with multiple copies of the same * character. * * @param n A number of copies to create. * @param c A character to copy. */ ncname (std::size_t n, C c) : base_type (n, c) { } /** * @brief Initialize an instance with a copy of a standard %string. * * @param s A standard %string to copy. */ ncname (const std::basic_string& s) : base_type (s) { } /** * @brief Initialize an instance with a copy of a substring. * * @param s A standard %string to copy the substring from. * @param pos An index of the first character to copy from. * @param n A number of characters to copy. */ ncname (const std::basic_string& s, std::size_t pos, std::size_t n = std::basic_string::npos) : base_type (s, pos, n) { } public: /** * @brief Copy constructor. * * @param x An instance to make a copy of. * @param f Flags to create the copy with. * @param c A pointer to the object that will contain the copy. * * For polymorphic object models use the @c _clone function instead. */ ncname (const ncname& x, flags f = 0, container* c = 0) : base_type (x, f, c) { } /** * @brief Copy the instance polymorphically. * * @param f Flags to create the copy with. * @param c A pointer to the object that will contain the copy. * @return A pointer to the dynamically allocated copy. * * This function ensures that the dynamic type of the instance * is used for copying and should be used for polymorphic object * models instead of the copy constructor. */ virtual ncname* _clone (flags f = 0, container* c = 0) const; public: /** * @brief Create an instance from a data representation * stream. * * @param s A stream to extract the data from. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ template ncname (istream& s, flags f = 0, container* c = 0); /** * @brief Create an instance from a DOM element. * * @param e A DOM element to extract the data from. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ ncname (const xercesc::DOMElement& e, flags f = 0, container* c = 0); /** * @brief Create an instance from a DOM Attribute. * * @param a A DOM attribute to extract the data from. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ ncname (const xercesc::DOMAttr& a, flags f = 0, container* c = 0); /** * @brief Create an instance from a %string fragment. * * @param s A %string fragment to extract the data from. * @param e A pointer to DOM element containing the %string fragment. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ ncname (const std::basic_string& s, const xercesc::DOMElement* e, flags f = 0, container* c = 0); //@} public: /** * @brief Assign a character to the instance. * * The resulting %ncname has only one character. * * @param c A character to assign. * @return A reference to the instance. */ ncname& operator= (C c) { base () = c; return *this; } /** * @brief Assign a C %string to the instance. * * The resulting %ncname contains a copy of the C %string. * * @param s A C %string to assign. * @return A reference to the instance. */ ncname& operator= (const C* s) { base () = s; return *this; } /** * @brief Assign a standard %string to the instance. * * The resulting %ncname contains a copy of the standard %string. * * @param s A standard %string to assign. * @return A reference to the instance. */ ncname& operator= (const std::basic_string& s) { base () = s; return *this; } /** * @brief Copy assignment operator. * * @param x An instance to assign. * @return A reference to the instance. */ ncname& operator= (const ncname& x) { base () = x; return *this; } protected: //@cond ncname () : base_type () { } //@endcond template friend class qname; }; /** * @brief Class corresponding to the XML Schema %language built-in * type. * * The %language class publicly inherits from and has the same set * of constructors as @c std::basic_string. It therefore can be * used as @c std::string (or @c std::wstring if you are using * @c wchar_t as the character type). * * @nosubgrouping */ template class language: public B { typedef B base_type; base_type& base () { return *this; } public: /** * @name Constructors */ //@{ /** * @brief Initialize an instance with a copy of a C %string. * * @param s A C %string to copy. */ language (const C* s) : base_type (s) { } /** * @brief Initialize an instance with a character array. * * @param s A character array to copy. * @param n A number of character to copy. */ language (const C* s, std::size_t n) : base_type (s, n) { } /** * @brief Initialize an instance with multiple copies of the same * character. * * @param n A number of copies to create. * @param c A character to copy. */ language (std::size_t n, C c) : base_type (n, c) { } /** * @brief Initialize an instance with a copy of a standard %string. * * @param s A standard %string to copy. */ language (const std::basic_string& s) : base_type (s) { } /** * @brief Initialize an instance with a copy of a substring. * * @param s A standard %string to copy the substring from. * @param pos An index of the first character to copy from. * @param n A number of characters to copy. */ language (const std::basic_string& s, std::size_t pos, std::size_t n = std::basic_string::npos) : base_type (s, pos, n) { } public: /** * @brief Copy constructor. * * @param x An instance to make a copy of. * @param f Flags to create the copy with. * @param c A pointer to the object that will contain the copy. * * For polymorphic object models use the @c _clone function instead. */ language (const language& x, flags f = 0, container* c = 0) : base_type (x, f, c) { } /** * @brief Copy the instance polymorphically. * * @param f Flags to create the copy with. * @param c A pointer to the object that will contain the copy. * @return A pointer to the dynamically allocated copy. * * This function ensures that the dynamic type of the instance * is used for copying and should be used for polymorphic object * models instead of the copy constructor. */ virtual language* _clone (flags f = 0, container* c = 0) const; public: /** * @brief Create an instance from a data representation * stream. * * @param s A stream to extract the data from. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ template language (istream& s, flags f = 0, container* c = 0); /** * @brief Create an instance from a DOM element. * * @param e A DOM element to extract the data from. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ language (const xercesc::DOMElement& e, flags f = 0, container* c = 0); /** * @brief Create an instance from a DOM Attribute. * * @param a A DOM attribute to extract the data from. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ language (const xercesc::DOMAttr& a, flags f = 0, container* c = 0); /** * @brief Create an instance from a %string fragment. * * @param s A %string fragment to extract the data from. * @param e A pointer to DOM element containing the %string fragment. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ language (const std::basic_string& s, const xercesc::DOMElement* e, flags f = 0, container* c = 0); //@} public: /** * @brief Assign a character to the instance. * * The resulting %language has only one character. * * @param c A character to assign. * @return A reference to the instance. */ language& operator= (C c) { base () = c; return *this; } /** * @brief Assign a C %string to the instance. * * The resulting %language contains a copy of the C %string. * * @param s A C %string to assign. * @return A reference to the instance. */ language& operator= (const C* s) { base () = s; return *this; } /** * @brief Assign a standard %string to the instance. * * The resulting %language contains a copy of the standard %string. * * @param s A standard %string to assign. * @return A reference to the instance. */ language& operator= (const std::basic_string& s) { base () = s; return *this; } /** * @brief Copy assignment operator. * * @param x An instance to assign. * @return A reference to the instance. */ language& operator= (const language& x) { base () = x; return *this; } protected: //@cond language () : base_type () { } //@endcond }; //@cond template struct identity_impl: identity { identity_impl (const ncname& id) : id_ (id) { } virtual bool before (const identity& y) const; virtual void throw_duplicate_id () const; private: const ncname& id_; }; //@endcond /** * @brief Class corresponding to the XML Schema ID built-in * type. * * The %id class publicly inherits from and has the same set * of constructors as @c std::basic_string. It therefore can be * used as @c std::string (or @c std::wstring if you are using * @c wchar_t as the character type). * * @nosubgrouping */ template class id: public B { typedef B base_type; base_type& base () { return *this; } public: ~id() { unregister_id (); } public: /** * @name Constructors */ //@{ /** * @brief Initialize an instance with a copy of a C %string. * * @param s A C %string to copy. */ id (const C* s) : base_type (s), identity_ (*this) { register_id (); } /** * @brief Initialize an instance with a character array. * * @param s A character array to copy. * @param n A number of character to copy. */ id (const C* s, std::size_t n) : base_type (s, n), identity_ (*this) { register_id (); } /** * @brief Initialize an instance with multiple copies of the same * character. * * @param n A number of copies to create. * @param c A character to copy. */ id (std::size_t n, C c) : base_type (n, c), identity_ (*this) { register_id (); } /** * @brief Initialize an instance with a copy of a standard %string. * * @param s A standard %string to copy. */ id (const std::basic_string& s) : base_type (s), identity_ (*this) { register_id (); } /** * @brief Initialize an instance with a copy of a substring. * * @param s A standard %string to copy the substring from. * @param pos An index of the first character to copy from. * @param n A number of characters to copy. */ id (const std::basic_string& s, std::size_t pos, std::size_t n = std::basic_string::npos) : base_type (s, pos, n), identity_ (*this) { register_id (); } public: /** * @brief Copy constructor. * * @param x An instance to make a copy of. * @param f Flags to create the copy with. * @param c A pointer to the object that will contain the copy. * * For polymorphic object models use the @c _clone function instead. */ id (const id& x, flags f = 0, container* c = 0) : base_type (x, f, c), identity_ (*this) { register_id (); } /** * @brief Copy the instance polymorphically. * * @param f Flags to create the copy with. * @param c A pointer to the object that will contain the copy. * @return A pointer to the dynamically allocated copy. * * This function ensures that the dynamic type of the instance * is used for copying and should be used for polymorphic object * models instead of the copy constructor. */ virtual id* _clone (flags f = 0, container* c = 0) const; public: /** * @brief Create an instance from a data representation * stream. * * @param s A stream to extract the data from. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ template id (istream& s, flags f = 0, container* c = 0); /** * @brief Create an instance from a DOM element. * * @param e A DOM element to extract the data from. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ id (const xercesc::DOMElement& e, flags f = 0, container* c = 0); /** * @brief Create an instance from a DOM Attribute. * * @param a A DOM attribute to extract the data from. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ id (const xercesc::DOMAttr& a, flags f = 0, container* c = 0); /** * @brief Create an instance from a %string fragment. * * @param s A %string fragment to extract the data from. * @param e A pointer to DOM element containing the %string fragment. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ id (const std::basic_string& s, const xercesc::DOMElement* e, flags f = 0, container* c = 0); //@} public: /** * @brief Assign a character to the instance. * * The resulting %id has only one character. * * @param c A character to assign. * @return A reference to the instance. */ id& operator= (C c); /** * @brief Assign a C %string to the instance. * * The resulting %id contains a copy of the C %string. * * @param s A C %string to assign. * @return A reference to the instance. */ id& operator= (const C* s); /** * @brief Assign a standard %string to the instance. * * The resulting %id contains a copy of the standard %string. * * @param s A standard %string to assign. * @return A reference to the instance. */ id& operator= (const std::basic_string& s); /** * @brief Copy assignment operator. * * @param x An instance to assign. * @return A reference to the instance. */ id& operator= (const id& x); public: //@cond virtual void _container (container*); // The above override also hides other _container versions. We // also cannot do using-declarations because of bugs in HP aCC3. // const container* _container () const { return B::_container (); } container* _container () { return B::_container (); } //@endcond protected: //@cond id () : base_type (), identity_ (*this) { register_id (); } //@endcond private: void register_id (); void unregister_id (); private: identity_impl identity_; }; /** * @brief Class corresponding to the XML Schema IDREF built-in * type. * * The %idref class publicly inherits from and has the same set * of constructors as @c std::basic_string. It therefore can be * used as @c std::string (or @c std::wstring if you are using * @c wchar_t as the character type). * * The %idref class also provides an autopointer-like interface * for resolving referenced objects. By default the object is * returned as type (mapping for anyType) but statically-typed * %idref can be created using the XML Schema extension. See the * C++/Tree Mapping User Manual for more information. * * @nosubgrouping */ template class idref: public B { typedef B base_type; base_type& base () { return *this; } public: /** * @brief Referenced type. */ typedef T ref_type; public: /** * @name Constructors */ //@{ /** * @brief Initialize an instance with a copy of a C %string. * * @param s A C %string to copy. */ idref (const C* s) : base_type (s), identity_ (*this) { } /** * @brief Initialize an instance with a character array. * * @param s A character array to copy. * @param n A number of character to copy. */ idref (const C* s, std::size_t n) : base_type (s, n), identity_ (*this) { } /** * @brief Initialize an instance with multiple copies of the same * character. * * @param n A number of copies to create. * @param c A character to copy. */ idref (std::size_t n, C c) : base_type (n, c), identity_ (*this) { } /** * @brief Initialize an instance with a copy of a standard %string. * * @param s A standard %string to copy. */ idref (const std::basic_string& s) : base_type (s), identity_ (*this) { } /** * @brief Initialize an instance with a copy of a substring. * * @param s A standard %string to copy the substring from. * @param pos An index of the first character to copy from. * @param n A number of characters to copy. */ idref (const std::basic_string& s, std::size_t pos, std::size_t n = std::basic_string::npos) : base_type (s, pos, n), identity_ (*this) { } public: /** * @brief Copy constructor. * * @param x An instance to make a copy of. * @param f Flags to create the copy with. * @param c A pointer to the object that will contain the copy. * * For polymorphic object models use the @c _clone function instead. */ idref (const idref& x, flags f = 0, container* c = 0) : base_type (x, f, c), identity_ (*this) { } /** * @brief Copy the instance polymorphically. * * @param f Flags to create the copy with. * @param c A pointer to the object that will contain the copy. * @return A pointer to the dynamically allocated copy. * * This function ensures that the dynamic type of the instance * is used for copying and should be used for polymorphic object * models instead of the copy constructor. */ virtual idref* _clone (flags f = 0, container* c = 0) const; public: /** * @brief Create an instance from a data representation * stream. * * @param s A stream to extract the data from. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ template idref (istream& s, flags f = 0, container* c = 0); /** * @brief Create an instance from a DOM element. * * @param e A DOM element to extract the data from. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ idref (const xercesc::DOMElement& e, flags f = 0, container* c = 0); /** * @brief Create an instance from a DOM Attribute. * * @param a A DOM attribute to extract the data from. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ idref (const xercesc::DOMAttr& a, flags f = 0, container* c = 0); /** * @brief Create an instance from a %string fragment. * * @param s A %string fragment to extract the data from. * @param e A pointer to DOM element containing the %string fragment. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ idref (const std::basic_string& s, const xercesc::DOMElement* e, flags f = 0, container* c = 0); //@} public: /** * @brief Assign a character to the instance. * * The resulting %idref has only one character. * * @param c A character to assign. * @return A reference to the instance. */ idref& operator= (C c) { base () = c; return *this; } /** * @brief Assign a C %string to the instance. * * The resulting %idref contains a copy of the C %string. * * @param s A C %string to assign. * @return A reference to the instance. */ idref& operator= (const C* s) { base () = s; return *this; } /** * @brief Assign a standard %string to the instance. * * The resulting %idref contains a copy of the standard %string. * * @param s A standard %string to assign. * @return A reference to the instance. */ idref& operator= (const std::basic_string& s) { base () = s; return *this; } /** * @brief Copy assignment operator. * * @param x An instance to assign. * @return A reference to the instance. */ idref& operator= (const idref& x) { base () = x; return *this; } public: /** * @brief Call referenced object. * * @return A constant pointer to the referenced object. */ const ref_type* operator-> () const { return get (); } /** * @brief Call referenced object. * * @return A pointer to the referenced object. */ ref_type* operator-> () { return get (); } /** * @brief Dereference referenced object. * * @return A constant C++ reference to the referenced object. */ const ref_type& operator* () const { return *(get ()); } /** * @brief Dereference referenced object. * * @return A C++ reference to the referenced object. */ ref_type& operator* () { return *(get ()); } /** * @brief Get a constant pointer to the referenced object. * * @return A constant pointer to the referenced object or 0 if * the object is not found. */ const ref_type* get () const { return dynamic_cast (get_ ()); } /** * @brief Get a pointer to the referenced object. * * @return A pointer to the referenced object or 0 if the object * is not found. */ ref_type* get () { return dynamic_cast (get_ ()); } /** * @brief Opaque type that can be evaluated as true or false. */ typedef void (idref::*bool_convertible)(); /** * @brief Implicit conversion to boolean type. * * @return True if the referenced object is found, false otherwise. */ operator bool_convertible () const { return get_ () ? &idref::true_ : 0; } protected: //@cond idref () : base_type (), identity_ (*this) { } //@endcond private: const _type* get_ () const; _type* get_ (); void true_ (); private: identity_impl identity_; }; /** * @brief Class corresponding to the XML Schema IDREFS built-in * type. * * The %idrefs class is a vector (or %list in XML Schema terminology) * of idref elements. It is implemented in terms of the list class * template. * * @nosubgrouping */ template class idrefs: public B, public list { typedef list base_type; public: /** * @name Constructors */ //@{ /** * @brief Default constructor creates no elements. */ idrefs () : base_type (0, this) { } /** * @brief Initialize the instance with copies of an exemplar elements. * * @param n A number of elements to copy. * @param x An exemplar element to copy. */ idrefs (typename base_type::size_type n, const idref& x) : base_type (n, x, this) { } /** * @brief Initialize the instance with copies of elements from an * iterator range. * * @param begin An iterator pointing to the first element. * @param end An iterator pointing to the one past the last element. */ template idrefs (const I& begin, const I& end) : base_type (begin, end, this) { } public: /** * @brief Copy constructor. * * @param x An instance to make a copy of. * @param f Flags to create the copy with. * @param c A pointer to the object that will contain the copy. * * For polymorphic object models use the @c _clone function instead. */ idrefs (const idrefs& x, flags f = 0, container* c = 0) : B (x, f, c), base_type (x, f, this) { } /** * @brief Copy the instance polymorphically. * * @param f Flags to create the copy with. * @param c A pointer to the object that will contain the copy. * @return A pointer to the dynamically allocated copy. * * This function ensures that the dynamic type of the instance * is used for copying and should be used for polymorphic object * models instead of the copy constructor. */ virtual idrefs* _clone (flags f = 0, container* c = 0) const; public: /** * @brief Create an instance from a data representation * stream. * * @param s A stream to extract the data from. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ template idrefs (istream& s, flags f = 0, container* c = 0); /** * @brief Create an instance from a DOM element. * * @param e A DOM element to extract the data from. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ idrefs (const xercesc::DOMElement& e, flags f = 0, container* c = 0); /** * @brief Create an instance from a DOM Attribute. * * @param a A DOM attribute to extract the data from. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ idrefs (const xercesc::DOMAttr& a, flags f = 0, container* c = 0); /** * @brief Create an instance from a %string fragment. * * @param s A %string fragment to extract the data from. * @param e A pointer to DOM element containing the %string fragment. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ idrefs (const std::basic_string& s, const xercesc::DOMElement* e, flags f = 0, container* c = 0); //@} }; /** * @brief Class corresponding to the XML Schema anyURI built-in * type. * * The %uri class publicly inherits from and has the same set * of constructors as @c std::basic_string. It therefore can be * used as @c std::string (or @c std::wstring if you are using * @c wchar_t as the character type). * * @nosubgrouping */ template class uri: public B, public std::basic_string { typedef std::basic_string base_type; base_type& base () { return *this; } public: /** * @name Constructors */ //@{ /** * @brief Initialize an instance with a copy of a C %string. * * @param s A C %string to copy. */ uri (const C* s) : base_type (s) { } /** * @brief Initialize an instance with a character array. * * @param s A character array to copy. * @param n A number of character to copy. */ uri (const C* s, std::size_t n) : base_type (s, n) { } /** * @brief Initialize an instance with multiple copies of the same * character. * * @param n A number of copies to create. * @param c A character to copy. */ uri (std::size_t n, C c) : base_type (n, c) { } /** * @brief Initialize an instance with a copy of a standard %string. * * @param s A standard %string to copy. */ uri (const std::basic_string& s) : base_type (s) { } /** * @brief Initialize an instance with a copy of a substring. * * @param s A standard %string to copy the substring from. * @param pos An index of the first character to copy from. * @param n A number of characters to copy. */ uri (const std::basic_string& s, std::size_t pos, std::size_t n = std::basic_string::npos) : base_type (s, pos, n) { } public: /** * @brief Copy constructor. * * @param x An instance to make a copy of. * @param f Flags to create the copy with. * @param c A pointer to the object that will contain the copy. * * For polymorphic object models use the @c _clone function instead. */ uri (const uri& x, flags f = 0, container* c = 0) : B (x, f, c), base_type (x) { } /** * @brief Copy the instance polymorphically. * * @param f Flags to create the copy with. * @param c A pointer to the object that will contain the copy. * @return A pointer to the dynamically allocated copy. * * This function ensures that the dynamic type of the instance * is used for copying and should be used for polymorphic object * models instead of the copy constructor. */ virtual uri* _clone (flags f = 0, container* c = 0) const; public: /** * @brief Create an instance from a data representation * stream. * * @param s A stream to extract the data from. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ template uri (istream& s, flags f = 0, container* c = 0); /** * @brief Create an instance from a DOM element. * * @param e A DOM element to extract the data from. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ uri (const xercesc::DOMElement& e, flags f = 0, container* c = 0); /** * @brief Create an instance from a DOM Attribute. * * @param a A DOM attribute to extract the data from. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ uri (const xercesc::DOMAttr& a, flags f = 0, container* c = 0); /** * @brief Create an instance from a %string fragment. * * @param s A %string fragment to extract the data from. * @param e A pointer to DOM element containing the %string fragment. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ uri (const std::basic_string& s, const xercesc::DOMElement* e, flags f = 0, container* c = 0); //@} public: /** * @brief Assign a character to the instance. * * The resulting %uri has only one character. * * @param c A character to assign. * @return A reference to the instance. */ uri& operator= (C c) { base () = c; return *this; } /** * @brief Assign a C %string to the instance. * * The resulting %uri contains a copy of the C %string. * * @param s A C %string to assign. * @return A reference to the instance. */ uri& operator= (const C* s) { base () = s; return *this; } /** * @brief Assign a standard %string to the instance. * * The resulting %uri contains a copy of the standard %string. * * @param s A standard %string to assign. * @return A reference to the instance. */ uri& operator= (const std::basic_string& s) { base () = s; return *this; } /** * @brief Copy assignment operator. * * @param x An instance to assign. * @return A reference to the instance. */ uri& operator= (const uri& x) { base () = x; return *this; } protected: //@cond uri () : base_type () { } //@endcond template friend class qname; }; /** * @brief Class corresponding to the XML Schema QName built-in * type. * * The %qname class represents a potentially namespace-qualified * XML %name. * * @nosubgrouping */ template class qname: public B { public: /** * @name Constructors */ //@{ /** * @brief Initialize an instance with a %name only. * * The resulting %qname is unqualified. * * @param n An XML %name (ncname). */ qname (const ncname& n) : ns_ (), name_ (n) { } /** * @brief Initialize an instance with a %name and a namespace. * * The resulting %qname is qualified. * * @param ns An XML namespace (uri). * @param n An XML %name (ncname). */ qname (const uri& ns, const ncname& n) : ns_ (ns), name_ (n) { } public: /** * @brief Copy constructor. * * @param x An instance to make a copy of. * @param f Flags to create the copy with. * @param c A pointer to the object that will contain the copy. * * For polymorphic object models use the @c _clone function instead. */ qname (const qname& x, flags f = 0, container* c = 0) : B (x, f, c), ns_ (x.ns_), name_ (x.name_) { // Note that ns_ and name_ have no DOM association. // } /** * @brief Copy the instance polymorphically. * * @param f Flags to create the copy with. * @param c A pointer to the object that will contain the copy. * @return A pointer to the dynamically allocated copy. * * This function ensures that the dynamic type of the instance * is used for copying and should be used for polymorphic object * models instead of the copy constructor. */ virtual qname* _clone (flags f = 0, container* c = 0) const; public: /** * @brief Create an instance from a data representation * stream. * * @param s A stream to extract the data from. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ template qname (istream& s, flags f = 0, container* c = 0); /** * @brief Create an instance from a DOM element. * * @param e A DOM element to extract the data from. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ qname (const xercesc::DOMElement& e, flags f = 0, container* c = 0); /** * @brief Create an instance from a DOM Attribute. * * @param a A DOM attribute to extract the data from. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ qname (const xercesc::DOMAttr& a, flags f = 0, container* c = 0); /** * @brief Create an instance from a %string fragment. * * @param s A %string fragment to extract the data from. * @param e A pointer to DOM element containing the %string fragment. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ qname (const std::basic_string& s, const xercesc::DOMElement* e, flags f = 0, container* c = 0); //@} public: /** * @brief Determine if the %name is qualified. * * @return True if the %name is qualified, false otherwise. */ bool qualified () const { return !ns_.empty (); } /** * @brief Get XML namespace. * * @return A constant reference to qualifying XML namespace. */ const uri& namespace_ () const { return ns_; } /** * @brief Get XML %name. * * @return A constant reference to unqualified XML %name. */ const ncname& name () const { return name_; } protected: //@cond qname () : ns_ (), name_ () { } //@endcond private: static uri resolve (const std::basic_string&, const xercesc::DOMElement*); private: uri ns_; ncname name_; }; /** * @brief %qname comparison operator. * * @return True if the names are equal, false otherwise. */ template inline bool operator== (const qname& a, const qname& b) { return a.name () == b.name () && a.namespace_ () == b.namespace_ (); } /** * @brief %qname comparison operator. * * @return True if the names are not equal, false otherwise. */ template inline bool operator!= (const qname& a, const qname& b) { return !(a == b); } /** * @brief Class corresponding to the XML Schema base64Binary * built-in type. * * The %base64_binary class is a binary %buffer abstraction with * base64-encoded representation in XML. It publicly inherits from * the buffer class which provides the %buffer functionality. * * @nosubgrouping */ template class base64_binary: public B, public buffer { public: typedef typename buffer::size_t size_t; public: /** * @name Constructors */ //@{ /** * @brief Allocate a %buffer of the specified size. * * The resulting %buffer has the same size and capacity. * * @param size A %buffer size in bytes. */ explicit base64_binary (size_t size = 0); /** * @brief Allocate a %buffer of the specified size and capacity. * * @param size A %buffer size in bytes. * @param capacity A %buffer capacity in bytes. * @throw bounds If @a size exceeds @a capacity */ base64_binary (size_t size, size_t capacity); /** * @brief Allocate a %buffer of the specified size and copy * the data. * * The resulting %buffer has the same size and capacity with * @a size bytes copied from @a data. * * @param data A %buffer to copy the data from. * @param size A %buffer size in bytes. */ base64_binary (const void* data, size_t size); /** * @brief Allocate a %buffer of the specified size and capacity * and copy the data. * * @a size bytes are copied from @a data to the resulting * %buffer. * * @param data A %buffer to copy the data from. * @param size A %buffer size in bytes. * @param capacity A %buffer capacity in bytes. * @throw bounds If @a size exceeds @a capacity */ base64_binary (const void* data, size_t size, size_t capacity); /** * @brief Assume ownership of the specified %buffer. * * If the @a assume_ownership argument is true, the %buffer will * assume ownership of @a data and will release the memory * by calling @c operator @c delete(). * * @param data A %buffer to assume ownership of. * @param size A %buffer size in bytes. * @param capacity A %buffer capacity in bytes. * @param assume_ownership A boolean value indication whether to * assume ownership. * @throw bounds If @a size exceeds @a capacity */ base64_binary (void* data, size_t size, size_t capacity, bool assume_ownership); public: /** * @brief Copy constructor. * * @param x An instance to make a copy of. * @param f Flags to create the copy with. * @param c A pointer to the object that will contain the copy. * * For polymorphic object models use the @c _clone function instead. */ base64_binary (const base64_binary& x, flags f = 0, container* c = 0) : B (x, f, c), buffer (x) { } /** * @brief Copy the instance polymorphically. * * @param f Flags to create the copy with. * @param c A pointer to the object that will contain the copy. * @return A pointer to the dynamically allocated copy. * * This function ensures that the dynamic type of the instance * is used for copying and should be used for polymorphic object * models instead of the copy constructor. */ virtual base64_binary* _clone (flags f = 0, container* c = 0) const; public: /** * @brief Create an instance from a data representation * stream. * * @param s A stream to extract the data from. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ template base64_binary (istream& s, flags f = 0, container* c = 0); /** * @brief Create an instance from a DOM element. * * @param e A DOM element to extract the data from. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ base64_binary (const xercesc::DOMElement& e, flags f = 0, container* c = 0); /** * @brief Create an instance from a DOM Attribute. * * @param a A DOM attribute to extract the data from. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ base64_binary (const xercesc::DOMAttr& a, flags f = 0, container* c = 0); /** * @brief Create an instance from a %string fragment. * * @param s A %string fragment to extract the data from. * @param e A pointer to DOM element containing the %string fragment. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ base64_binary (const std::basic_string& s, const xercesc::DOMElement* e, flags f = 0, container* c = 0); //@} public: /** * @brief Copy assignment operator. * * @param x An instance to assign. * @return A reference to the instance. */ base64_binary& operator= (const base64_binary& x) { buffer& b (*this); b = x; return *this; } public: /** * @brief Encode the %buffer in base64 encoding. * * @return A %string with base64-encoded data. */ std::basic_string encode () const; private: void decode (const XMLCh*); }; /** * @brief Class corresponding to the XML Schema hexBinary * built-in type. * * The %hex_binary class is a binary %buffer abstraction with * hex-encoded representation in XML. It publicly inherits from * the buffer class which provides the %buffer functionality. * * @nosubgrouping */ template class hex_binary: public B, public buffer { public: typedef typename buffer::size_t size_t; public: /** * @name Constructors */ //@{ /** * @brief Allocate a %buffer of the specified size. * * The resulting %buffer has the same size and capacity. * * @param size A %buffer size in bytes. */ explicit hex_binary (size_t size = 0); /** * @brief Allocate a %buffer of the specified size and capacity. * * @param size A %buffer size in bytes. * @param capacity A %buffer capacity in bytes. * @throw bounds If @a size exceeds @a capacity */ hex_binary (size_t size, size_t capacity); /** * @brief Allocate a %buffer of the specified size and copy * the data. * * The resulting %buffer has the same size and capacity with * @a size bytes copied from @a data. * * @param data A %buffer to copy the data from. * @param size A %buffer size in bytes. */ hex_binary (const void* data, size_t size); /** * @brief Allocate a %buffer of the specified size and capacity * and copy the data. * * @a size bytes are copied from @a data to the resulting * %buffer. * * @param data A %buffer to copy the data from. * @param size A %buffer size in bytes. * @param capacity A %buffer capacity in bytes. * @throw bounds If @a size exceeds @a capacity */ hex_binary (const void* data, size_t size, size_t capacity); /** * @brief Assume ownership of the specified %buffer. * * If the @a assume_ownership argument is true, the %buffer will * assume ownership of @a data and will release the memory * by calling @c operator @c delete(). * * @param data A %buffer to assume ownership of. * @param size A %buffer size in bytes. * @param capacity A %buffer capacity in bytes. * @param assume_ownership A boolean value indication whether to * assume ownership. * @throw bounds If @a size exceeds @a capacity */ hex_binary (void* data, size_t size, size_t capacity, bool assume_ownership); public: /** * @brief Copy constructor. * * @param x An instance to make a copy of. * @param f Flags to create the copy with. * @param c A pointer to the object that will contain the copy. * * For polymorphic object models use the @c _clone function instead. */ hex_binary (const hex_binary& x, flags f = 0, container* c = 0) : B (x, f, c), buffer (x) { } /** * @brief Copy the instance polymorphically. * * @param f Flags to create the copy with. * @param c A pointer to the object that will contain the copy. * @return A pointer to the dynamically allocated copy. * * This function ensures that the dynamic type of the instance * is used for copying and should be used for polymorphic object * models instead of the copy constructor. */ virtual hex_binary* _clone (flags f = 0, container* c = 0) const; public: /** * @brief Create an instance from a data representation * stream. * * @param s A stream to extract the data from. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ template hex_binary (istream& s, flags f = 0, container* c = 0); /** * @brief Create an instance from a DOM element. * * @param e A DOM element to extract the data from. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ hex_binary (const xercesc::DOMElement& e, flags f = 0, container* c = 0); /** * @brief Create an instance from a DOM Attribute. * * @param a A DOM attribute to extract the data from. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ hex_binary (const xercesc::DOMAttr& a, flags f = 0, container* c = 0); /** * @brief Create an instance from a %string fragment. * * @param s A %string fragment to extract the data from. * @param e A pointer to DOM element containing the %string fragment. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ hex_binary (const std::basic_string& s, const xercesc::DOMElement* e, flags f = 0, container* c = 0); //@} public: /** * @brief Copy assignment operator. * * @param x An instance to assign. * @return A reference to the instance. */ hex_binary& operator= (const hex_binary& x) { buffer& b (*this); b = x; return *this; } public: /** * @brief Encode the %buffer in hex encoding. * * @return A %string with hex-encoded data. */ std::basic_string encode () const; private: void decode (const XMLCh*); }; /** * @brief Class corresponding to the XML Schema ENTITY built-in * type. * * The %entity class publicly inherits from and has the same set * of constructors as @c std::basic_string. It therefore can be * used as @c std::string (or @c std::wstring if you are using * @c wchar_t as the character type). * * @nosubgrouping */ template class entity: public B { typedef B base_type; base_type& base () { return *this; } public: /** * @name Constructors */ //@{ /** * @brief Initialize an instance with a copy of a C %string. * * @param s A C %string to copy. */ entity (const C* s) : base_type (s) { } /** * @brief Initialize an instance with a character array. * * @param s A character array to copy. * @param n A number of character to copy. */ entity (const C* s, std::size_t n) : base_type (s, n) { } /** * @brief Initialize an instance with multiple copies of the same * character. * * @param n A number of copies to create. * @param c A character to copy. */ entity (std::size_t n, C c) : base_type (n, c) { } /** * @brief Initialize an instance with a copy of a standard %string. * * @param s A standard %string to copy. */ entity (const std::basic_string& s) : base_type (s) { } /** * @brief Initialize an instance with a copy of a substring. * * @param s A standard %string to copy the substring from. * @param pos An index of the first character to copy from. * @param n A number of characters to copy. */ entity (const std::basic_string& s, std::size_t pos, std::size_t n = std::basic_string::npos) : base_type (s, pos, n) { } public: /** * @brief Copy constructor. * * @param x An instance to make a copy of. * @param f Flags to create the copy with. * @param c A pointer to the object that will contain the copy. * * For polymorphic object models use the @c _clone function instead. */ entity (const entity& x, flags f = 0, container* c = 0) : base_type (x, f, c) { } /** * @brief Copy the instance polymorphically. * * @param f Flags to create the copy with. * @param c A pointer to the object that will contain the copy. * @return A pointer to the dynamically allocated copy. * * This function ensures that the dynamic type of the instance * is used for copying and should be used for polymorphic object * models instead of the copy constructor. */ virtual entity* _clone (flags f = 0, container* c = 0) const; public: /** * @brief Create an instance from a data representation * stream. * * @param s A stream to extract the data from. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ template entity (istream& s, flags f = 0, container* c = 0); /** * @brief Create an instance from a DOM element. * * @param e A DOM element to extract the data from. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ entity (const xercesc::DOMElement& e, flags f = 0, container* c = 0); /** * @brief Create an instance from a DOM Attribute. * * @param a A DOM attribute to extract the data from. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ entity (const xercesc::DOMAttr& a, flags f = 0, container* c = 0); /** * @brief Create an instance from a %string fragment. * * @param s A %string fragment to extract the data from. * @param e A pointer to DOM element containing the %string fragment. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ entity (const std::basic_string& s, const xercesc::DOMElement* e, flags f = 0, container* c = 0); //@} public: /** * @brief Assign a character to the instance. * * The resulting %entity has only one character. * * @param c A character to assign. * @return A reference to the instance. */ entity& operator= (C c) { base () = c; return *this; } /** * @brief Assign a C %string to the instance. * * The resulting %entity contains a copy of the C %string. * * @param s A C %string to assign. * @return A reference to the instance. */ entity& operator= (const C* s) { base () = s; return *this; } /** * @brief Assign a standard %string to the instance. * * The resulting %entity contains a copy of the standard %string. * * @param s A standard %string to assign. * @return A reference to the instance. */ entity& operator= (const std::basic_string& s) { base () = s; return *this; } /** * @brief Copy assignment operator. * * @param x An instance to assign. * @return A reference to the instance. */ entity& operator= (const entity& x) { base () = x; return *this; } protected: //@cond entity () : base_type () { } //@endcond }; /** * @brief Class corresponding to the XML Schema ENTITIES built-in * type. * * The %entities class is a vector (or %list in XML Schema terminology) * of entity elements. It is implemented in terms of the list class * template. * * @nosubgrouping */ template class entities: public B, public list { typedef list base_type; public: /** * @name Constructors */ //@{ /** * @brief Default constructor creates no elements. */ entities () : base_type (0, this) { } /** * @brief Initialize the instance with copies of an exemplar elements. * * @param n A number of elements to copy. * @param x An exemplar element to copy. */ entities (typename base_type::size_type n, const entity& x) : base_type (n, x, this) { } /** * @brief Initialize the instance with copies of elements from an * iterator range. * * @param begin An iterator pointing to the first element. * @param end An iterator pointing to the one past the last element. */ template entities (const I& begin, const I& end) : base_type (begin, end, this) { } public: /** * @brief Copy constructor. * * @param x An instance to make a copy of. * @param f Flags to create the copy with. * @param c A pointer to the object that will contain the copy. * * For polymorphic object models use the @c _clone function instead. */ entities (const entities& x, flags f = 0, container* c = 0) : B (x, f, c), base_type (x, f, this) { } /** * @brief Copy the instance polymorphically. * * @param f Flags to create the copy with. * @param c A pointer to the object that will contain the copy. * @return A pointer to the dynamically allocated copy. * * This function ensures that the dynamic type of the instance * is used for copying and should be used for polymorphic object * models instead of the copy constructor. */ virtual entities* _clone (flags f = 0, container* c = 0) const; public: /** * @brief Create an instance from a data representation * stream. * * @param s A stream to extract the data from. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ template entities (istream& s, flags f = 0, container* c = 0); /** * @brief Create an instance from a DOM element. * * @param e A DOM element to extract the data from. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ entities (const xercesc::DOMElement& e, flags f = 0, container* c = 0); /** * @brief Create an instance from a DOM Attribute. * * @param a A DOM attribute to extract the data from. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ entities (const xercesc::DOMAttr& a, flags f = 0, container* c = 0); /** * @brief Create an instance from a %string fragment. * * @param s A %string fragment to extract the data from. * @param e A pointer to DOM element containing the %string fragment. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ entities (const std::basic_string& s, const xercesc::DOMElement* e, flags f = 0, container* c = 0); //@} }; } } } #include #endif // XSD_CXX_TREE_TYPES_HXX