From 0fdf19714613a82a184f4f6e75fb9a4f9b62f18a Mon Sep 17 00:00:00 2001
From: Boris Kolpackov The C++/Tree mapping provides support for ISO/IEC C++ 1998/2003 (C++98)
+ and ISO/IEC C++ 2011 (C++11). To select the C++ standard for the
+ generated code we use the XML Schema names may happen to be reserved C++ keywords or contain
characters that are illegal in C++ identifiers. To avoid C++ compilation
@@ -563,7 +573,7 @@
CONVENTION section in the XSD
Compiler Command Line Manual. The code that implements the mapping, depending on the
The mapping relies on some predefined types, classes, and functions
that are logically defined in the XML Schema namespace reserved for
@@ -605,7 +615,7 @@
For the purpose of code generation, anonymous types defined in
XML Schema are automatically assigned names that are derived
@@ -1132,9 +1142,10 @@ namespace system
sequences of non-fundamental C++ types is the addition of
the overloaded
@@ -517,7 +518,16 @@
2.1 Preliminary Information
-
- 2.1.1 Identifiers
- 2.1.2 Character Type and Encoding
- 2.1.3 XML Schema Namespace
+ 2.1.4 Anonymous Types
+ 2.1.1 C++ Standard
+ 2.1.2 Identifiers
+ 2.1.3 Character Type and Encoding
+ 2.1.4 XML Schema Namespace 2.1.5 Anonymous Types 2.1 Preliminary Information
- 2.1.1 Identifiers
+ 2.1.1 C++ Standard
+
+ --std
XSD compiler command
+ line option. While the majority of the examples in this manual use
+ C++98, support for the new functionality and library components
+ introduced in C++11 are discussed throughout the document.2.1.2 Identifiers
2.1.2 Character Type and Encoding
+ 2.1.3 Character Type and Encoding
--char-type
option, is generated using either
@@ -588,7 +598,7 @@
encoding is UTF-16. On other platforms wchar_t
is 4 bytes
long and UTF-32/UCS-4 is used.2.1.3 XML Schema Namespace
+ 2.1.4 XML Schema Namespace
2.1.4 Anonymous Types
+ 2.1.5 Anonymous Types
push_back
and insert
member functions which instead of the constant reference
- to the element type accept automatic pointer to the element
- type. These functions assume ownership of the pointed to
- object and resets the passed automatic pointer.
+ to the element type accept automatic pointer (std::auto_ptr
+ or std::unique_ptr
, depending on the C++ standard
+ selected) to the element type. These functions assume ownership
+ of the pointed to object and reset the passed automatic pointer.
2.5.1 Inheritance from Built-in Data Types
@@ -2317,9 +2328,10 @@ public:
sequences of non-fundamental C++ types is the addition of
the overloaded push_back
and insert
member functions which instead of the constant reference
- to the element type accept automatic pointer to the element
- type. These functions assume ownership of the pointed to
- object and resets the passed automatic pointer.
+ to the element type accept automatic pointer (std::auto_ptr
+ or std::unique_ptr
, depending on the C++ standard
+ selected) to the element type. These functions assume ownership
+ of the pointed to object and reset the passed automatic pointer.
std::auto_ptr
. In this case the newly
+ either std::auto_ptr
(C++98) or std::unique_ptr
+ (C++11), depending on the C++ standard selected. In this case the newly
created instance is directly initialized with and assumes ownership
- of the pointed to objects and the std::auto_ptr
arguments
- are reset to 0
. For instance:
+ of the pointed to objects and the std::[auto|unique]_ptr
+ arguments are reset to 0
. For instance:
<complexType name="complex"> @@ -2432,7 +2445,7 @@ class object: xml_schema::type { public: object (const bool& s_one, const complex& c_one); - object (const bool& s_one, std::auto_ptr<complex>& c_one); + object (const bool& s_one, std::[auto|unique]_ptr<complex> c_one); object (const object&); public: @@ -2449,7 +2462,7 @@ public:
Notice that the generated complex
class does not
- have the second (std::auto_ptr
) version of the
+ have the second (std::[auto|unique]_ptr
) version of the
constructor since all its required members are of simple types.
If an XML Schema complex type has an ultimate base which is an XML @@ -2720,9 +2733,10 @@ public: constant of the member's type. It makes a deep copy of its argument. Except for member's types that are mapped to fundamental C++ types, the second modifier function is provided that expects an argument - of type automatic pointer to the member's type. It assumes ownership - of the pointed to object and resets the passed automatic pointer. - For instance:
+ of type automatic pointer (std::auto_ptr
or
+ std::unique_ptr
, depending on the C++ standard selected)
+ to the member's type. It assumes ownership of the pointed to object
+ and resets the passed automatic pointer. For instance:
<complexType name="object"> @@ -2756,7 +2770,7 @@ public: member (const member_type&); void - member (std::auto_ptr<member_type>); + member (std::[auto|unique]_ptr<member_type>); ... }; @@ -2773,7 +2787,7 @@ class object: xml_schema::type public: ... - std::auto_ptr<member_type> + std::[auto|unique]_ptr<member_type> detach_member (); ... @@ -2798,10 +2812,19 @@ f (object& o) o.member ("hello"); // set, deep copy o.member () = "hello"; // set, deep copy + // C++98 version. + // std::auto_ptr<string> p (new string ("hello")); o.member (p); // set, assumes ownership p = o.detach_member (); // detach, member is uninitialized o.member (p); // re-attach + + // C++11 version. + // + std::unique_ptr<string> p (new string ("hello")); + o.member (std::move (p)); // set, assumes ownership + p = o.detach_member (); // detach, member is uninitialized + o.member (std::move (p)); // re-attach }@@ -2831,11 +2854,12 @@ f (object& o) member's type. It makes a deep copy of its argument. Except for member's types that are mapped to fundamental C++ types, the second modifier function is provided that expects an argument - of type automatic pointer to the member's type. It assumes ownership - of the pointed to object and resets the passed automatic pointer. - The last modifier function expects an argument of type reference - to constant of the container type. It makes a deep copy of its - argument. For instance: + of type automatic pointer (
std::auto_ptr
or
+ std::unique_ptr
, depending on the C++ standard selected)
+ to the member's type. It assumes ownership of the pointed to object
+ and resets the passed automatic pointer. The last modifier function
+ expects an argument of type reference to constant of the container
+ type. It makes a deep copy of its argument. For instance:
@@ -2871,7 +2895,7 @@ public: member (const member_type&); void - member (std::auto_ptr<member_type>); + member (std::[auto|unique]_ptr<member_type>); void member (const member_optional&); @@ -2884,7 +2908,7 @@ public:@@ -3104,9 +3141,11 @@ public: the overloadedThe
@@ -2904,7 +2928,7 @@ public: // Assumes ownership. // explicit - optional (std::auto_ptr<X>); + optional (std::[auto|unique]_ptr<X>); optional (const optional&); @@ -2953,11 +2977,11 @@ public: // Assumes ownership. // void - set (std::auto_ptr<X>); + set (std::[auto|unique]_ptr<X>); // Detach and return the contained value. // - std::auto_ptr<X> + std::[auto|unique]_ptr<X> detach (); void @@ -3016,6 +3040,8 @@ f (object& o) o.member ().reset (); // reset } + // C++98 version. + // std::auto_ptr<string> p (new string ("hello")); o.member (p); // set, assumes ownership @@ -3024,6 +3050,17 @@ f (object& o) p = o.member ().detach (); // detach, member is reset o.member ().set (p); // re-attach + + // C++11 version. + // + std::unique_ptr<string> p (new string ("hello")); + o.member (std::move (p)); // set, assumes ownership + + p.reset (new string ("hello")); + o.member ().set (std::move (p)); // set, assumes ownership + + p = o.member ().detach (); // detach, member is reset + o.member ().set (std::move (p)); // re-attach }optional
class template is defined in an implementation-specific namespace and has the following - interface. Theauto_ptr
-based constructor + interface. The[auto|unique]_ptr
-based constructor and modifier function are only available if the template argument is not a fundamental C++ type.
push_back
and insert
as well as the detach_back
and detach
member functions. The additional push_back
and
- insert
functions accept an automatic pointer to the
+ insert
functions accept an automatic pointer
+ (std::auto_ptr
or std::unique_ptr
,
+ depending on the C++ standard selected) to the
element type instead of the constant reference. They assume
- ownership of the pointed to object and resets the passed
+ ownership of the pointed to object and reset the passed
automatic pointer. The detach_back
and
detach
functions detach the element
value from the sequence container and, by default, remove
@@ -3121,17 +3160,17 @@ public:
...
void
- push_back (std::auto_ptr<X>)
+ push_back (std::[auto|unique]_ptr<X>)
iterator
- insert (iterator position, std::auto_ptr<X>)
+ insert (iterator position, std::[auto|unique]_ptr<X>)
- std::auto_ptr<X>
+ std::[auto|unique]_ptr<X>
detach_back (bool pop = true);
iterator
detach (iterator position,
- std::auto_ptr<X>& result,
+ std::[auto|unique]_ptr<X>& result,
bool erase = true)
...
@@ -3159,11 +3198,20 @@ f (object& o)
//
s.push_back ("hello"); // deep copy
+ // C++98 version.
+ //
std::auto_ptr<string> p (new string ("hello"));
s.push_back (p); // assumes ownership
p = s.detach_back (); // detach and pop
s.push_back (p); // re-append
+ // C++11 version.
+ //
+ std::unique_ptr<string> p (new string ("hello"));
+ s.push_back (std::move (p)); // assumes ownership
+ p = s.detach_back (); // detach and pop
+ s.push_back (std::move (p)); // re-append
+
// Setting a new container.
//
object::member_sequence n;
@@ -3192,14 +3240,16 @@ f (object& o)
The parsing functions read XML instance documents and return
- corresponding object models. Their signatures
+ corresponding object models as an automatic pointer
+ (std::auto_ptr
or std::unique_ptr
,
+ depending on the C++ standard selected). Their signatures
have the following pattern (type
denotes
element's type and name
denotes element's
name):
-std::auto_ptr<type> +std::[auto|unique]_ptr<type> name (....);@@ -3207,9 +3257,8 @@ name (....); functions, is the subject of Chapter 3, "Parsing". -
The serialization functions write object models - back to XML instance documents. Their signatures - have the following pattern: +
The serialization functions write object models back to XML instance + documents. Their signatures have the following pattern:
@@ -3272,13 +3321,13 @@ public: value (const value_type&); void - value (std::auto_ptr<value_type>); + value (std::[auto|unique]_ptr<value_type>); // Constructors. // root (const value_type&); - root (std::auto_ptr<value_type>); + root (std::[auto|unique]_ptr<value_type>); root (const xercesc::DOMElement&, xml_schema::flags = 0); @@ -3374,7 +3423,7 @@ namespace xml_schema class element_map { public: - static std::auto_ptr<xml_schema::element_type> + static std::[auto|unique]_ptr<xml_schema::element_type> parse (const xercesc::DOMElement&, flags = 0); static void @@ -3385,7 +3434,9 @@ namespace xml_schema@@ -4672,8 +4723,11 @@ name (xml_schema::dom::auto_ptr<xercesc::DOMDocument>&,The
parse()
function creates the corresponding element type object based on the element name and namespace - and returns it as a pointer toxml_schema::element_type
. + and returns it as an automatic pointer (std::auto_ptr
+ orstd::unique_ptr
, depending on the C++ standard + selected) toxml_schema::element_type
. Theserialize()
function serializes the passed element object toDOMElement
. Note that in case ofserialize()
, theDOMElement
object @@ -4574,18 +4625,18 @@ f (object& o, const xercesc::DOMAttr& a) // Read from a URI or a local file. // -std::auto_ptr<type> +std::[auto|unique]_ptr<type> name (const std::basic_string<C>& uri, xml_schema::flags = 0, const xml_schema::properties& = xml_schema::properties ()); -std::auto_ptr<type> +std::[auto|unique]_ptr<type> name (const std::basic_string<C>& uri, xml_schema::error_handler&, xml_schema::flags = 0, const xml_schema::properties& = xml_schema::properties ()); -std::auto_ptr<type> +std::[auto|unique]_ptr<type> name (const std::basic_string<C>& uri, xercesc::DOMErrorHandler&, xml_schema::flags = 0, @@ -4595,38 +4646,38 @@ name (const std::basic_string<C>& uri, // Read from std::istream. // -std::auto_ptr<type> +std::[auto|unique]_ptr<type> name (std::istream&, xml_schema::flags = 0, const xml_schema::properties& = xml_schema::properties ()); -std::auto_ptr<type> +std::[auto|unique]_ptr<type> name (std::istream&, xml_schema::error_handler&, xml_schema::flags = 0, const xml_schema::properties& = xml_schema::properties ()); -std::auto_ptr<type> +std::[auto|unique]_ptr<type> name (std::istream&, xercesc::DOMErrorHandler&, xml_schema::flags = 0, const xml_schema::properties& = xml_schema::properties ()); -std::auto_ptr<type> +std::[auto|unique]_ptr<type> name (std::istream&, const std::basic_string<C>& id, xml_schema::flags = 0, const xml_schema::properties& = xml_schema::properties ()); -std::auto_ptr<type> +std::[auto|unique]_ptr<type> name (std::istream&, const std::basic_string<C>& id, xml_schema::error_handler&, xml_schema::flags = 0, const xml_schema::properties& = xml_schema::properties ()); -std::auto_ptr<type> +std::[auto|unique]_ptr<type> name (std::istream&, const std::basic_string<C>& id, xercesc::DOMErrorHandler&, @@ -4637,18 +4688,18 @@ name (std::istream&, // Read from InputSource. // -std::auto_ptr<type> +std::[auto|unique]_ptr<type> name (xercesc::InputSource&, xml_schema::flags = 0, const xml_schema::properties& = xml_schema::properties ()); -std::auto_ptr<type> +std::[auto|unique]_ptr<type> name (xercesc::InputSource&, xml_schema::error_handler&, xml_schema::flags = 0, const xml_schema::properties& = xml_schema::properties ()); -std::auto_ptr<type> +std::[auto|unique]_ptr<type> name (xercesc::InputSource&, xercesc::DOMErrorHandler&, xml_schema::flags = 0, @@ -4658,13 +4709,13 @@ name (xercesc::InputSource&, // Read from DOM. // -std::auto_ptr<type> +std::[auto|unique]_ptr<type> name (const xercesc::DOMDocument&, xml_schema::flags = 0, const xml_schema::properties& = xml_schema::properties ()); -std::auto_ptr<type> -name (xml_schema::dom::auto_ptr<xercesc::DOMDocument>&, +std::[auto|unique]_ptr<type> +name (xml_schema::dom::[auto|unique]_ptr<xercesc::DOMDocument>, xml_schema::flags = 0, const xml_schema::properties& = xml_schema::properties ());
You can choose between reading an XML instance from a local file,
URI, std::istream
, xercesc::InputSource
,
or a pre-parsed DOM instance in the form of
- xercesc::DOMDocument
. Each of these parsing functions
- is discussed in more detail in the following sections.
+ xercesc::DOMDocument
. All the parsing functions
+ return a dynamically allocated object model as either
+ std::auto_ptr
or std::unique_ptr
,
+ depending on the C++ standard selected. Each of these parsing
+ functions is discussed in more detail in the following sections.
keep_dom
flag in
the call to the parsing function with the
- xml_schema::dom::auto_ptr<DOMDocument>
+ xml_schema::dom::[auto|unique]_ptr<DOMDocument>
argument.xml_schema::flags::dont_validate
Or, in the C++11 mode:
+ ++using std::unique_ptr; + +unique_ptr<type> r1 (name ("test.xml")); +unique_ptr<type> r2 (name ("http://www.codesynthesis.com/test.xml")); ++
std::istream
When using an std::istream
instance, you may also
@@ -5220,21 +5283,30 @@ std::auto_ptr<type> r (name (is));
The last parsing function is useful when you would like to perform
your own XML-to-DOM parsing and associate the resulting DOM document
- with the object model nodes. If parsing is successeful, the
- automatic DOMDocument
pointer is reset and the
- resulting object model assumes ownership of the DOM document
- passed. For example:
DOMDocument
+ pointer is reset and the resulting object model assumes ownership
+ of the DOM document passed. For example:
+// C++98 version. +// xml_schema::dom::auto_ptr<xercesc::DOMDocument> doc = ... std::auto_ptr<type> r ( name (doc, xml_schema::flags::keep_dom | xml_schema::flags::own_dom)); // At this point doc is reset to 0. -+// C++11 version. +// +xml_schema::dom::unique_ptr<xercesc::DOMDocument> doc = ... + +std::unique_ptr<type> r ( + name (std::move (doc), + xml_schema::flags::keep_dom | xml_schema::flags::own_dom)); +// At this point doc is reset to 0. +
// Parse XML to object model. // -std::auto_ptr<type> r = root ("root.xml"); +std::auto_ptr<type> r (root ("root.xml")); // Save to a CDR stream. // -- cgit v1.1