/****************************************************************************

**

** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtXmlPatterns module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

/*

 * QXmlName is conceptually identical to QPatternist::QName. The

 * difference is that the latter is elegant, powerful and fast.

 *

 * However, it is too powerful and too open and not at all designed

 * for being public. QXmlName, in contrast, is only a public marker,

 * that for instance uses a qint64 instead of qint32, such that we in

 * the future can use that, if needed.

 */

#include "qnamepool_p.h"

#include "qxmlname.h"

#include "qxmlnamepool.h"

#include "qxpathhelper_p.h"

#include "private/qxmlutils_p.h"

QT_BEGIN_NAMESPACE

/*!

  \class QXmlName

  \brief The QXmlName class represents the name of an XML node, in an efficient, namespace-aware way.

  \reentrant

  \since 4.4

  \ingroup xml-tools

  QXmlName represents the name of an XML node in a way that

  is both efficient and safe for comparing names. Normally,

  an XML node represents an XML element or attribute, but

  QXmlName can also represent the names of other kinds of

  nodes, e.g., QAbstractXmlReceiver::processingInstruction()

  and QAbstractXmlReceiver::namespaceBinding().

  The name of an XML node has three components: The \e {namespace

  URI}, the \e {local name}, and the \e {prefix}. To see what these

  refer to in XML, consider the following snippet.

  \quotefile doc/src/snippets/patternist/mobeyDick.xml

  For the element named \e book, localName() returns \e book,

  namespaceUri() returns \e http://example.com/MyDefault,

  and prefix() returns an empty string. For the element named

  \e title, localName() returns \e title, namespaceUri() returns

  \e http://purl.org/dc/elements/1.1, and prefix() returns \e dc.

  To ensure that operations with QXmlName are efficient, e.g.,

  copying names and comparing them, each instance of QXmlName is

  associated with a \l {QXmlNamePool} {name pool}, which must be

  specified at QXmlName construction time. The three components

  of the QXmlName, i.e., the namespace URI, the local name, and

  the prefix, are stored in the name pool mapped to identifiers

  so they can be shared. For this reason, the only way to create

  a valid instance of QXmlName is to use the class constructor,

  where the \l {QXmlNamePool} {name pool}, local name, namespace

  URI, and prefix must all be specified.

  Note that QXmlName's default constructor constructs a null

  instance. It is typically used for allocating unused entries

  in collections of QXmlName.

  A side effect of associating each instance of QXmlName with

  a \l {QXmlNamePool} {name pool} is that each instance of

  QXmlName is tied to the QXmlNamePool with which it was created.

  However, the QXmlName class does not keep track of the name pool,

  so all the accessor functions, e.g., namespaceUri(), prefix(),

  localName(), and toClarkName() require that the correct name

  pool be passed to them. Failure to provide the correct name

  pool to these accessor functions results in undefined behavior.

  Note that a \l {QXmlNamePool} {name pool} is \e not an XML

  namespace. One \l {QXmlNamePool} {name pool} can represent

  instances of QXmlName from different XML namespaces, and the

  instances of QXmlName from one XML namespace can be distributed

  over multiple  \l {QXmlNamePool} {name pools}.

  \target Comparing QXmlNames

  \section1 Comparing QXmlNames

  To determine what a QXmlName refers to, the \e {namespace URI}

  and the \e {local name} are used. The \e prefix is not used

  because the prefix is simply a shorthand name for use in place

  of the normally much longer namespace URI. Nor is the prefix

  used in name comparisons. For example, the following two element

  nodes represent the same element and compare equal.

  \quotefile doc/src/snippets/patternist/svgDocumentElement.xml

  \quotefile doc/src/snippets/patternist/xsvgDocumentElement.xml

  Although the second name has the prefix \e x, the two names compare

  equal as instances of QXmlName, because the prefix is not used in

  the comparison.

  A local name can never be an empty string, although the prefix and

  namespace URI can. If the prefix is not empty, the namespace URI

  cannot be empty. Local names and prefixes must be valid

  \l {http://www.w3.org/TR/REC-xml-names/#NT-NCName} {NCNames},

  e.g., \e abc.def or \e abc123.

  QXmlName represents what is sometimes called an \e {expanded QName},

  or simply a QName.

  \sa {http://www.w3.org/TR/REC-xml-names/#NT-NCName} {Namespaces in XML 1.0 (Second Edition), [4] NCName}

 */

/*!

   \enum QXmlName::Constant

   \internal

   Various constants used in the QPatternist::NamePool and QXmlName.

   Setting of the mask enums use essentially this:

   \quotefile doc/src/snippets/code/src_xmlpatterns_api_qxmlname.cpp

   The masks, such as LocalNameMask, are positive. That is, for the

   area which the name resides, the bits are set.

 */

/*!

 Constructs a QXmlName instance that inserts \a localName,

 \a namespaceURI and \a prefix into \a namePool if they aren't

 already there. The accessor functions namespaceUri(), prefix(),

 localName(), and toClarkName() must be passed the \a namePool

 used here, so the \a namePool must remain in scope while the

 accessor functions might be used. However, two instances can

 be compared with \e {==} or \e {!=} and copied without the

 \a namePool.

 The user guarantees that the string components are valid for a

 QName. In particular, the local name, and the prefix (if present),

 must be valid \l {http://www.w3.org/TR/REC-xml-names/#NT-NCName}

 {NCNames}. The function isNCName() can be used to test validity

 of these names. The namespace URI should be an absolute URI.

 QUrl::isRelative() can be used to test whether the namespace URI

 is relative or absolute. Finally, providing a prefix is not valid

 when no namespace URI is provided.

 \a namePool is not copied. Nor is the reference to it retained

 in this instance. This constructor inserts the three strings

 into \a namePool.

 */

QXmlName::QXmlName(QXmlNamePool &namePool,

                   const QString &localName,

                   const QString &namespaceURI,

                   const QString &prefix)

{

    Q_ASSERT_X(prefix.isEmpty() || QXmlUtils::isNCName(prefix), Q_FUNC_INFO,

               "The prefix is invalid, maybe the arguments were mixed up?");

    Q_ASSERT_X(QXmlUtils::isNCName(localName), Q_FUNC_INFO,

               "The local name is invalid, maybe the arguments were mixed up?");

    m_qNameCode = namePool.d->allocateQName(namespaceURI, localName, prefix).code();

}

/*!

  \typedef QXmlName::Code

  \internal

   Stores the \l {QXmlNamePool} {name pool} identifiers for

   the namespace URI, local name, and prefix.

 */

/*!

  Returns true if this QXmlName is not initialized with a

  valid combination of \e {namespace URI}, \e {local name},

  and \e {prefix}.

  A valid local name is always required. The prefix and

  namespace URI can be empty, but if the prefix is not empty,

  the namespace URI must not be empty. Local names and

  prefixes must be valid

  \l {http://www.w3.org/TR/REC-xml-names/#NT-NCName} {NCNames},

  e.g., \e abc.def or \e abc123.

 */

bool QXmlName::isNull() const

{

    return m_qNameCode == InvalidCode;

}

/*!

  Constructs an uninitialized QXmlName. To build

  a valid QXmlName, you normally use the other constructor, which

  takes a \l {QXmlNamePool} {name pool}, namespace URI, local name,

  and prefix as parameters. But you can also use this constructor

  to build a null QXmlName and then assign an existing QXmlName

  to it.

  \sa isNull()

 */

QXmlName::QXmlName() : m_qNameCode(InvalidCode)

{

}

/*!

  \fn QXmlName::QXmlName(const NamespaceCode uri,

                         const LocalNameCode ln,

                         const PrefixCode p = 0)

  \internal

 */

/*!

  \fn QXmlName::hasPrefix() const

  \internal

  Returns true if this QXmlName has a non-empty prefix. If this

  function returns true, hasNamespace() will also return true,

  because a QXmlName can't have a prefix if it doesn't have a

  namespace URI.

 */

/*!

  \fn bool QXmlName::hasNamespace() const

  \internal

  Returns true if this QXmlName has a non-empty namespace URI.

 */

/*!

  \fn Code QXmlName::code() const

  \internal

  Returns the internal code that contains the id codes for the

  local name, prefix and namespace URI. It is opaque when used

  outside QXmlName, but it can be useful when one wants to put

  a QXmlName in a hash, and the prefix is significant.

 */

/*!

  Returns true if this QXmlName is equal to \a other; otherwise false.

  Two QXmlNames are equal if their namespace URIs are the same \e and

  their local names are the same. The prefixes are ignored.

  Note that it is meaningless to compare two instances of QXmlName

  that were created with different \l {QXmlNamePool} {name pools},

  but the attempt is not detected and the behavior is undefined.

  \sa operator!=()

 */

bool QXmlName::operator==(const QXmlName &other) const

{

    return (m_qNameCode & ExpandedNameMask) == (other.m_qNameCode & ExpandedNameMask);

}

/*!

  Returns true if this QXmlName is \e not equal to \a other;

  otherwise false. Two QXmlNames are equal if their namespace

  URIs are the same \e and their local names are the same. They

  are not equal if either their namespace URIs differ or their

  local names differ. Their prefixes are ignored.

  Note that it is meaningless to compare two instances of QXmlName

  that were created with different \l {QXmlNamePool} {name pools},

  but the attempt is not detected and the behavior is undefined.

  \sa operator==()

 */

bool QXmlName::operator!=(const QXmlName &other) const

{

    return !operator==(other);

}

/*!

  \fn bool QXmlName::isLexicallyEqual(const QXmlName &other) const

  \internal

  Returns true if this and \a other are lexically equal. Two

  QXmlNames are lexically equal if their local names are equal

  \e and their prefixes are equal.

 */

/*!

 \fn uint qHash(const QXmlName &name)

 \since 4.4

 \relates QXmlName

 Computes a hash key from the local name and the namespace

 URI in \a name. The prefix in \a name is not used in the computation.

 */

uint qHash(const QXmlName &name)

{

    return name.m_qNameCode & QXmlName::ExpandedNameMask;

}

/*!

 Returns the namespace URI.

 Note that for efficiency, the namespace URI string is not

 stored in the QXmlName but in the \l {QXmlNamePool} that was

 passed to the constructor. Hence, that same \a namePool must

 be passed to this function, so it can be used for looking up

 the namespace URI.

 */

QString QXmlName::namespaceUri(const QXmlNamePool &namePool) const

{

    if(isNull())

        return QString();

    else

        return namePool.d->stringForNamespace(namespaceURI());

}

/*!

 Returns the prefix.

 Note that for efficiency, the prefix string is not stored in

 the QXmlName but in the \l {QXmlNamePool} that was passed to

 the constructor. Hence, that same \a namePool must be passed

 to this function, so it can be used for looking up the prefix.

 */

QString QXmlName::prefix(const QXmlNamePool &namePool) const

{

    if(isNull())

        return QString();

    else

        return namePool.d->stringForPrefix(prefix());

}

/*!

 Returns the local name.

 Note that for efficiency, the local name string is not stored

 in the QXmlName but in the \l {QXmlNamePool} that was passed to

 the constructor. Hence, that same \a namePool must be passed

 to this function, so it can be used for looking up the

 local name.

 */

QString QXmlName::localName(const QXmlNamePool &namePool) const

{

    if(isNull())

        return QString();

    else

        return namePool.d->stringForLocalName(localName());

}

/*!

  Returns this QXmlName formatted as a Clark Name. For example,

  if the local name is \c html, the prefix is \c x, and the

  namespace URI is \c {http://www.w3.org/1999/xhtml/},

  then the Clark Name returned is:

  \code

  {http://www.w3.org/1999/xhtml/}x:html.

  \endcode

  If the local name is \e {MyWidget} and the namespace is empty,

  the Clark Name returned is:

  \code

  MyWidget

  \endcode

  Note that for efficiency, the namespace URI, local name, and

  prefix strings are not stored in the QXmlName but in the

  \l {QXmlNamePool} that was passed to the constructor. Hence,

  that same \a namePool must be passed to this function, so it

  can be used for looking up the three string components.

  This function can be useful for debugging.

 \sa {http://www.jclark.com/xml/xmlns.htm} {XML Namespaces, James Clark}

 \sa fromClarkName()

 */

QString QXmlName::toClarkName(const QXmlNamePool &namePool) const

{

    return namePool.d->toClarkName(*this);

}

/*!

  Assigns \a other to \e this and returns \e this.

 */

QXmlName &QXmlName::operator=(const QXmlName &other)

{

    m_qNameCode = other.m_qNameCode;

    return *this;

}

/*!

 Returns true if \a candidate is an \c NCName. An \c NCName

 is a string that can be used as a name in XML and XQuery,

 e.g., the prefix or local name in an element or attribute,

 or the name of a variable.

 \sa {http://www.w3.org/TR/REC-xml-names/#NT-NCName} {Namespaces in XML 1.0 (Second Edition), [4] NCName}

 */

bool QXmlName::isNCName(const QString &candidate)

{

    return QXmlUtils::isNCName(candidate);

}

/*!

  Converts \a clarkName into a QXmlName, inserts into \a namePool, and

  returns it.

  A clark name is a way to present a full QName with only one string, where

  the namespace cannot contain braces. Here are a couple of examples:

    \table

    \header

        \o Clark Name

        \o Description

    \row

        \o \c html

        \o The local name \c html, in no namespace

    \row

        \o \c {http://www.w3.org/1999/xhtml}html

        \o The local name \c html, in the XHTML namespace

    \row

        \o \c {http://www.w3.org/1999/xhtml}my:html

        \o The local name \c html, in the XHTML namespace, with the prefix \c my

    \endtable

    If the namespace contains braces, the returned value is either invalid or

    has undefined content.

    If \a clarkName is an invalid name, a default constructed QXmlName is

    returned.

  \since 4.5

  \sa toClarkName()

 */

QXmlName QXmlName::fromClarkName(const QString &clarkName,

                                 const QXmlNamePool &namePool)

{

    return namePool.d->fromClarkName(clarkName);

}

/*!

  \typedef QXmlName::LocalNameCode

  \internal

 */

/*!

  \typedef QXmlName::PrefixCode

  \internal

 */

/*!

  \typedef QXmlName::NamespaceCode

  \internal

 */

/*!

  \fn void QXmlName::setLocalName(const LocalNameCode c)

  \internal

*/

/*!

  \fn LocalNameCode QXmlName::localName() const

  \internal

*/

/*!

  \fn PrefixCode QXmlName::prefix() const

  \internal

*/

/*!

  \fn NamespaceCode QXmlName::namespaceURI() const

  \internal

*/

/*!

  \fn void QXmlName::setNamespaceURI(const NamespaceCode c)

  \internal

*/

/*!

  \fn void QXmlName::setPrefix(const PrefixCode c)

  \internal

*/

QT_END_NAMESPACE