Update QtXmlPatterns module name in documentation

According to new module name convention, QtXmlPatterns is
replaced with Qt XML Patterns in all documentation.

Task-number: QTBUG-24775
Change-Id: I1951b7cc1bb47f3b9e4e73bd380ffef1196396a2
Reviewed-by: Casper van Donderen <casper.vandonderen@nokia.com>

7 files changed, 59 insertions, 59 deletions

diff --git a/doc/src/examples/filetree.qdoc b/doc/src/examples/filetree.qdoc
index c9106d7..82fdeaf 100644
--- a/doc/src/examples/filetree.qdoc
+++ b/doc/src/examples/filetree.qdoc
@@ -29,7 +29,7 @@
   \example xmlpatterns/filetree
   \title File System Example
 
-  This example shows how to use QtXmlPatterns for querying non-XML
+  This example shows how to use Qt XML Patterns for querying non-XML
   data that is modeled to look like XML. 
 
   \tableofcontents
@@ -80,7 +80,7 @@
   The strategy is to create a custom node model that represents the
   directory tree of the computer's file system. That tree structure is
   non-XML data. The custom node model must have the same callback
-  interface as the XML node models that the QtXmlPatterns query engine
+  interface as the XML node models that the Qt XML Patterns query engine
   uses to execute queries. The query engine can then traverse the
   custom node model as if it were traversing the node model built from
   an XML document.
@@ -89,7 +89,7 @@
   create a custom node model by subclassing QAbstractXmlNodeModel and
   providing implementations for its pure virtual functions. For many
   cases, the implementations of several of the virtual functions are
-  always the same, so QtXmlPatterns also provides QSimpleXmlNodeModel,
+  always the same, so Qt XML Patterns also provides QSimpleXmlNodeModel,
   which subclasses QAbstractXmlNodeModel and provides implementations
   for the callback functions that you can ignore. By subclassing
   QSimpleXmlNodeModel instead of QAbstractXmlNodeModel, you can reduce
@@ -326,7 +326,7 @@
   \snippet examples/xmlpatterns/filetree/mainwindow.cpp 4
 
   \c{loadDirectory()} demonstrates a standard code pattern for using
-  QtXmlPatterns programatically. First it gets the node model index
+  Qt XML Patterns programatically. First it gets the node model index
   for the root of the selected directory. Then it creates an instance
   of QXmlQuery and calls QXmlQuery::bindVariable() to bind the node
   index to the XQuery variable \c{$fileTree}. It then calls
diff --git a/doc/src/examples/globalVariables.qdoc b/doc/src/examples/globalVariables.qdoc
index 86ed514..3288128 100644
--- a/doc/src/examples/globalVariables.qdoc
+++ b/doc/src/examples/globalVariables.qdoc
@@ -40,12 +40,12 @@
     violations and instances of bad or inefficient patterns. We can do
     it using the common searching and pattern matching utilities to
     process the C++ files (e.g., \c{grep}, \c{sed}, and \c{awk}). Now
-    we can also use XQuery with the QtXmlPatterns module.
+    we can also use XQuery with the Qt XML Patterns module.
 
     An extension to the \c{g++} open source C++ compiler
     (\l{http://public.kitware.com/GCC_XML/HTML/Index.html} {GCC-XML})
     generates an XML description of C++ source code declarations. This
-    XML description can then be processed by QtXmlPatterns using
+    XML description can then be processed by Qt XML Patterns using
     XQueries to navigate the XML description of the C++ source and
     produce a report. Consider the problem of finding mutable global
     variables:
diff --git a/doc/src/examples/recipes.qdoc b/doc/src/examples/recipes.qdoc
index 3688f17..745b747 100644
--- a/doc/src/examples/recipes.qdoc
+++ b/doc/src/examples/recipes.qdoc
@@ -29,7 +29,7 @@
   \example xmlpatterns/recipes
   \title Recipes Example
 
-  The Recipes example shows how to use QtXmlPatterns to query XML data
+  The Recipes example shows how to use Qt XML Patterns to query XML data
   loaded from a file. 
 
   \tableofcontents
@@ -109,7 +109,7 @@
   \snippet examples/xmlpatterns/recipes/querymainwindow.cpp 1
 
   \l{evaluate() function} {evaluate()} demonstrates the standard
-  QtXmlPatterns usage pattern. First, an instance of QXmlQuery is
+  Qt XML Patterns usage pattern. First, an instance of QXmlQuery is
   created (\c{query}). The \c{query's} \l{QXmlQuery::bindVariable()}
   {bindVariable()} function is then called to bind the \c cookbook.xml
   file to the XQuery variable \c inputDocument. \e{After} the variable
@@ -120,7 +120,7 @@
   \e{after} \l{QXmlQuery::bindVariable()} {bindVariable()}.
 
   Passing the XQuery to \l{QXmlQuery::setQuery()} {setQuery()} causes
-  QtXmlPatterns to parse the XQuery. \l{QXmlQuery::isValid()} is
+  Qt XML Patterns to parse the XQuery. \l{QXmlQuery::isValid()} is
   called to ensure that the XQuery was correctly parsed.
 
   \target evaluate() function
diff --git a/doc/src/examples/schema.qdoc b/doc/src/examples/schema.qdoc
index 0a1454c..9d56d6b 100644
--- a/doc/src/examples/schema.qdoc
+++ b/doc/src/examples/schema.qdoc
@@ -29,7 +29,7 @@
   \example xmlpatterns/schema
   \title XML Schema Validation Example
 
-  The XML Schema Validation example shows how to use QtXmlPatterns to
+  The XML Schema Validation example shows how to use Qt XML Patterns to
   validate XML with a W3C XML Schema.
 
   \tableofcontents
diff --git a/doc/src/xml-processing/xml-patterns.qdoc b/doc/src/xml-processing/xml-patterns.qdoc
index 7626912..c608df0 100644
--- a/doc/src/xml-processing/xml-patterns.qdoc
+++ b/doc/src/xml-processing/xml-patterns.qdoc
@@ -46,7 +46,7 @@
     XML or some other format. XPath is the \e{element selection} part
     of XQuery.
 
-    The QtXmlPatterns module supports using
+    The Qt XML Patterns module supports using
     \l{http://www.w3.org/TR/xquery} {XQuery 1.0} and
     \l{http://www.w3.org/TR/xpath20} {XPath 2.0} in Qt applications,
     for querying XML data \e{and} for querying
@@ -55,7 +55,7 @@
     Readers who are not familiar with the XQuery/XPath language can read
     \l {A Short Path to XQuery} for a brief introduction.
 
-    \section1 Advantages of using QtXmlPatterns and XQuery
+    \section1 Advantages of using Qt XML Patterns and XQuery
 
     The XQuery/XPath language simplifies data searching and
     transformation tasks by eliminating the need for doing a lot of
@@ -79,7 +79,7 @@
     as an attribute. Finally, the \c{<bibliography>} element is
     closed.
 
-    The advantages of using QtXmlPatterns and XQuery in your Qt
+    The advantages of using Qt XML Patterns and XQuery in your Qt
     programs are summarized as follows:
 
     \list
@@ -96,29 +96,29 @@
        data searching, selecting, and sorting tasks.
 
     \li \b{Conformance to standards}: Conformance to all applicable
-       XML and XQuery standards ensures that QtXmlPatterns can always
+       XML and XQuery standards ensures that Qt XML Patterns can always
        process XML documents generated by other conformant
-       applications, and that XML documents created with QtXmlPatterns
+       applications, and that XML documents created with Qt XML Patterns
        can be processed by other conformant applications.
 
-    \li \b{Maximal flexibility} The QtXmlPatterns module can be used
+    \li \b{Maximal flexibility} The Qt XML Patterns module can be used
        to query XML data \e{and} non-XML data that can be
        \l{QAbstractXmlNodeModel} {modeled to look like XML}.
 
     \endlist
 
-    \section1 Using the QtXmlPatterns module
+    \section1 Using the Qt XML Patterns module
 
-    There are two ways QtXmlPatterns can be used to evaluate queries.
+    There are two ways Qt XML Patterns can be used to evaluate queries.
     You can run the query engine in your Qt application using the
-    QtXmlPatterns C++ API, or you can run the query engine from the
+    Qt XML Patterns C++ API, or you can run the query engine from the
     command line using Qt's \c{xmlpatterns} command line utility.
 
     \section2 Running the query engine from your Qt application
 
     If we save the example XQuery shown above in a text file (e.g.
     \c{myquery.xq}), we can run it from a Qt application using a
-    standard QtXmlPatterns code sequence:
+    standard Qt XML Patterns code sequence:
 
     \snippet doc/src/snippets/code/src_xmlpatterns_api_qxmlquery.cpp 3
 
@@ -130,13 +130,13 @@
     the \l{QXmlQuery::}{evaluateTo()} function to evaluate the query
     and serialize the results as XML.
 
-    \note If you compile Qt yourself, the QtXmlPatterns module will
+    \note If you compile Qt yourself, the Qt XML Patterns module will
     \e{not} be built if exceptions are disabled, or if you compile Qt
     with a compiler that doesn't support member templates, e.g., MSVC
     6.
 
     See the QXmlQuery documentation for more information about the
-    QtXmlPatterns C++ API.
+    Qt XML Patterns C++ API.
 
     \section2 Running the query engine from the command line utility
 
@@ -184,15 +184,15 @@
     \target qtxmlpatterns_example_query2
     \quotefile snippets/patternist/introExample2.xq
 
-    Modify the QtXmlPatterns code to use one of the \l{QXmlQuery::}
+    Modify the Qt XML Patterns code to use one of the \l{QXmlQuery::}
     {bindVariable()} functions to bind a program variable to each
     XQuery $variable:
 
     \snippet doc/src/snippets/code/src_xmlpatterns_api_qxmlquery.cpp 4
 
-    Each program variable is passed to QtXmlPatterns as a QVariant of
+    Each program variable is passed to Qt XML Patterns as a QVariant of
     the type of the C++ variable or constant from which it is
-    constructed. Note that QtXmlPatterns assumes that the type of the
+    constructed. Note that Qt XML Patterns assumes that the type of the
     QVariant in the bindVariable() call is the correct type, so the
     $variable it is bound to must be used in the XQuery accordingly.
     The following table shows how QVariant types are mapped to XQuery
@@ -297,7 +297,7 @@
     {QXmlResultItems} {result items}, atomic values in the sequence
     are treated as instances of QVariant. Suppose that instead of
     serializing the results of the XQuery as XML, we process the
-    results programatically. Modify the standard QtXmlPatterns code
+    results programatically. Modify the standard Qt XML Patterns code
     sequence to call the overload of QXmlQuery::evaluateTo() that
     populates a sequence of \l {QXmlResultItems} {result items} with
     the XQuery results:
@@ -439,13 +439,13 @@
     \section1 Using XQuery with Non-XML Data
 
     Although the XQuery language was designed for querying XML, with
-    QtXmlPatterns one can use XQuery for querying any data that can
+    Qt XML Patterns one can use XQuery for querying any data that can
     be modeled to look like XML. Non-XML data is modeled to look like
     XML by loading it into a custom subclass of QAbstractXmlNodeModel,
-    where it is then presented to the QtXmlPatterns XQuery engine via
+    where it is then presented to the Qt XML Patterns XQuery engine via
     the same API the XQuery engine uses for querying XML.
 
-    When QtXmlPatterns loads and queries XML files and produces XML
+    When Qt XML Patterns loads and queries XML files and produces XML
     output, it can always load the XML data into its default XML node
     model, where it can be traversed efficiently. The XQuery below
     traverses the product orders found in the XML file \e myOrders.xml
@@ -454,12 +454,12 @@
 
     \quotefile snippets/patternist/introAcneRemover.xq
 
-    QtXmlPatterns can be used out of the box to perform this
+    Qt XML Patterns can be used out of the box to perform this
     query, provided \e myOrders.xml actually contains well-formed XML. It
     can be loaded directly into the default XML node model and
-    traversed. But suppose we want QtXmlPatterns to perform queries on
+    traversed. But suppose we want Qt XML Patterns to perform queries on
     the hierarchical structure of the local file system. The default
-    XML node model in QtXmlPatterns is not suitable for navigating the
+    XML node model in Qt XML Patterns is not suitable for navigating the
     file system, because there is no XML file to load that contains a
     description of it. Such an XML file, if it existed, might look
     something like this:
@@ -487,7 +487,7 @@
     \skipto <html>
     \printuntil
 
-    Without QtXmlPatterns, there is no simple way to solve this kind
+    Without Qt XML Patterns, there is no simple way to solve this kind
     of problem. You might do it by writing a C++ program to traverse
     the file system, sniff out all the XML files, and submit each one
     to an XML parser to test that it contains valid XML. The C++ code
@@ -507,7 +507,7 @@
     step system that results is inefficient because the two data
     models must be built and maintained separately.
 
-    With QtXmlPatterns, subclassing QAbstractXmlNodeModel eliminates
+    With Qt XML Patterns, subclassing QAbstractXmlNodeModel eliminates
     the transformation required to convert the non-XML data model to
     the XML data model, because there is only ever one data model
     required. The non-XML data model presents the non-XML data to the
@@ -523,7 +523,7 @@
     system.
 
     Examples of other places where XQuery could be used in
-    QtXmlPatterns to query non-XML data:
+    Qt XML Patterns to query non-XML data:
 
     \list
 
@@ -546,11 +546,11 @@
     See the QAbstractXmlNodeModel documentation for information about
     how to implement custom XML node models.
 
-    \section1 More on using QtXmlPatterns with non-XML Data
+    \section1 More on using Qt XML Patterns with non-XML Data
 
     Subclassing QAbstractXmlNodeModel to let the query engine access
     non-XML data by the same API it uses for XML is the feature that
-    enables QtXmlPatterns to query non-XML data with XQuery. It allows
+    enables Qt XML Patterns to query non-XML data with XQuery. It allows
     XQuery to be used as a mapping layer between different non-XML
     node models or between a non-XML node model and the built-in XML
     node model. Once the subclass(es) of QAbstractXmlNodeModel have
@@ -563,7 +563,7 @@
     data in several different formats. Rather than writing a lot of
     C++ code to convert each input format to an intermediate form, and
     more C++ code to convert the intermediate form back to each
-    output format, one can implement a solution based on QtXmlPatterns
+    output format, one can implement a solution based on Qt XML Patterns
     that uses simple XQueries to transform each XML or non-XML format
     (e.g. MathFormula.xml below) to the intermediate form (e.g. the
     DocumentRepresentation node model class below), and more simple
@@ -602,9 +602,9 @@
 
     \section2 Denial of Service Attacks
 
-    Applications using QtXmlPatterns are subject to the same
+    Applications using Qt XML Patterns are subject to the same
     limitations of software as other systems. Generally, these can not
-    be checked. This means QtXmlPatterns does not prevent rogue
+    be checked. This means Qt XML Patterns does not prevent rogue
     queries from consuming too many resources. For example, a query
     could take too much time to execute or try to transfer too much
     data. A query could also do too much recursion, which could crash
@@ -615,7 +615,7 @@
 
     \section2 XQuery 1.0
 
-    QtXmlPatterns aims at being a
+    Qt XML Patterns aims at being a
     \l{http://www.w3.org/TR/xquery/#id-xquery-conformance} {conformant
     XQuery processor}. It adheres to
     \l{http://www.w3.org/TR/xquery/#id-minimal-conformance} {Minimal
@@ -623,7 +623,7 @@
     \l{http://www.w3.org/TR/xquery/#id-serialization-feature}
     {Serialization Feature} and the
     \l{http://www.w3.org/TR/xquery/#id-full-axis-feature} {Full Axis
-    Feature}. QtXmlPatterns currently passes 97% of the tests in the
+    Feature}. Qt XML Patterns currently passes 97% of the tests in the
     \l{http://www.w3.org/XML/Query/test-suite} {XML Query Test Suite}.
     Areas where conformance may be questionable and where behavior may
     be changed in future releases include:
@@ -634,7 +634,7 @@
        are incorrect.
 
     \li XPath is a subset of XQuery and the implementation of
-       QtXmlPatterns uses XPath 2.0 with XQuery 1.0.
+       Qt XML Patterns uses XPath 2.0 with XQuery 1.0.
 
     \endlist
 
@@ -655,7 +655,7 @@
     \section2 XSLT 2.0
 
     Partial support for XSLT was introduced in Qt 4.5. Future
-    releases of QtXmlPatterns will aim to support these XSLT
+    releases of Qt XML Patterns will aim to support these XSLT
     features:
 
     \list
@@ -673,7 +673,7 @@
     in the following table. The implementation of XSLT in Qt 4.5 can
     be seen as XSLT 1.0 but with the data model of XPath 2.0 and
     XSLT 2.0, and using the using the functionality of XPath 2.0 and
-    its accompanying function library. When QtXmlPatterns encounters
+    its accompanying function library. When Qt XML Patterns encounters
     an unsupported or partially support feature, it will either report
     a syntax error or silently continue, unless otherwise noted in the
     table.
@@ -779,7 +779,7 @@
         \li Since XPath is a subset of XSLT, its issues are in affect too.
     \endtable
 
-    The QtXmlPatterns implementation of the XPath Data Model does not
+    The Qt XML Patterns implementation of the XPath Data Model does not
     include entities (due to QXmlStreamReader not reporting them).
     This means that functions \c unparsed-entity-uri() and \c
     unparsed-entity-public-id() always return negatively.
@@ -811,13 +811,13 @@
 
     \section2 XML Schema 1.0
 
-    There are two ways QtXmlPatterns can be used to validate schemas:
+    There are two ways Qt XML Patterns can be used to validate schemas:
     You can use the C++ API in your Qt application using the classes
     QXmlSchema and QXmlSchemaValidator, or you can use the command line
     utility named xmlpatternsvalidator (located in the "bin" directory
     of your Qt build).
 
-    The QtXmlPatterns implementation of XML Schema validation supports
+    The Qt XML Patterns implementation of XML Schema validation supports
     the schema specification version 1.0 in large parts. Known problems
     of the implementation and areas where conformancy may be questionable
     are:
@@ -838,7 +838,7 @@
 
     \section2 Resource Loading
 
-    When QtXmlPatterns loads an XML resource, e.g., using the
+    When Qt XML Patterns loads an XML resource, e.g., using the
     \c fn:doc() function, the following schemes are supported:
 
     \table
@@ -884,6 +884,6 @@
 
 /*!
     \namespace QPatternist
-    \brief The QPatternist namespace contains classes and functions required by the QtXmlPatterns module.
+    \brief The QPatternist namespace contains classes and functions required by the Qt XML Patterns module.
     \internal
 */
diff --git a/doc/src/xml-processing/xml-processing.qdoc b/doc/src/xml-processing/xml-processing.qdoc
index dfcf183..2a8ec0b 100644
--- a/doc/src/xml-processing/xml-processing.qdoc
+++ b/doc/src/xml-processing/xml-processing.qdoc
@@ -44,7 +44,7 @@
     \brief An Overview of the XML processing facilities in Qt.
 
     In addition to core XML support, classes for higher level querying
-    and manipulation of XML data are provided by the QtXmlPatterns
+    and manipulation of XML data are provided by the Qt XML Patterns
     module. In the QtSvg module, the QSvgRenderer and QSvgGenerator
     classes can read and write a subset of SVG, an XML-based file
     format. Qt also provides helper functions that may be useful to
diff --git a/doc/src/xml-processing/xquery-introduction.qdoc b/doc/src/xml-processing/xquery-introduction.qdoc
index 74c5cb1..3fde9aa 100644
--- a/doc/src/xml-processing/xquery-introduction.qdoc
+++ b/doc/src/xml-processing/xquery-introduction.qdoc
@@ -74,7 +74,7 @@ locating a file in a hierarchical file system. It is a sequence of one
 or more \e{steps} separated by slash '/' or double slash '//'.
 Although path expressions are used for traversing XML trees, not file
 systems, in QtXmlPatterms we can model a file system to look like an
-XML tree, so in QtXmlPatterns we can use XQuery to traverse a file
+XML tree, so in Qt XML Patterns we can use XQuery to traverse a file
 system. See the \l {File System Example} {file system example}.
 
 Think of a path expression as an algorithm for traversing an XML tree
@@ -89,7 +89,7 @@ result of the XQuery.  The items in the result set are presented in
 \l{http://www.w3.org/TR/xquery/#id-document-order} {document order}
 and without duplicates.
 
-With QtXmlPatterns, a standard way to present the initial focus to a
+With Qt XML Patterns, a standard way to present the initial focus to a
 query is to call QXmlQuery::setFocus(). Another common way is to let
 the XQuery itself create the initial focus by using the first step of
 the path expression to call the XQuery \c{doc()} function. The
@@ -176,7 +176,7 @@ that are available.
 \section2 Axis Specifiers
 
 An axis specifier defines the direction you want the query engine to
-take, when it navigates away from the context node. QtXmlPatterns
+take, when it navigates away from the context node. Qt XML Patterns
 supports the following axes.
 
 \table
@@ -235,9 +235,9 @@ expression can test just the \e kind of node, or it can test the \e
 kind of node and the \e name of the node. The XQuery specification for
 \l{http://www.w3.org/TR/xquery/#node-tests} {node tests} also defines
 a third condition, the node's \e {Schema Type}, but schema type tests
-are not supported in QtXmlPatterns.
+are not supported in Qt XML Patterns.
 
-QtXmlPatterns supports the following node tests. The tests that have a
+Qt XML Patterns supports the following node tests. The tests that have a
 \c{name} parameter test the node's name in addition to its \e{kind}
 and are often called the \l{Name Tests}.
 
@@ -404,14 +404,14 @@ Both methods will work and produce the same output, all the
 
 But note how the output is slightly different from the output we saw
 before we added the default namespace declaration to the cookbook file.
-QtXmlPatterns automatically includes the correct namespace attribute
-in each \c{<title>} element in the output. When QtXmlPatterns loads a
+Qt XML Patterns automatically includes the correct namespace attribute
+in each \c{<title>} element in the output. When Qt XML Patterns loads a
 document and expands a QName, it creates an instance of QXmlName,
 which retains the namespace prefix along with the namespace URI and
 the local name. See QXmlName for further details.
 
 One thing to keep in mind from this namespace discussion, whether you
-run XQueries in a Qt program using QtXmlPatterns, or you run them from
+run XQueries in a Qt program using Qt XML Patterns, or you run them from
 the command line using xmlpatterns, is that if you don't get the
 output you expect, it might be because the data you are querying uses
 namespaces, but you didn't declare those namespaces in your XQuery.