1 /****************************************************************************

     2 **

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

     4 ** All rights reserved.

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

     6 **

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

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

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

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

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

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

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

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

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

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

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

    23 **

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

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

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

    27 **

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

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

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 //

    43 //  W A R N I N G

    44 //  -------------

    45 //

    46 // This file is not part of the Qt API.  It exists purely as an

    47 // implementation detail.  This header file may change from version to

    48 // version without notice, or even be removed.

    49 //

    50 // We mean it.

    51 

    52 #ifndef Patternist_StringValueFNs_H

    53 #define Patternist_StringValueFNs_H

    54 

    55 #include <QByteArray>

    56 

    57 #include "qfunctioncall_p.h"

    58 

    59 /**

    60  * @file

    61  * @short Contains classes implementing the functions found in

    62  * <a href="http://www.w3.org/TR/xpath-functions/#string-value-functions">XQuery 1.0 and

    63  * XPath 2.0 Functions and Operators, 7.4 Functions on AtomicString Values</a>.

    64  *

    65  * @ingroup Patternist_functions

    66  */

    67 

    68 QT_BEGIN_HEADER

    69 

    70 QT_BEGIN_NAMESPACE

    71 

    72 namespace QPatternist

    73 {

    74 

    75     /**

    76      * @short Implements the function <tt>fn:concat()</tt>.

    77      *

    78      * @ingroup Patternist_functions

    79      * @author Frans Englich <frans.englich@nokia.com>

    80      */

    81     class ConcatFN : public FunctionCall

    82     {

    83     public:

    84         virtual Item evaluateSingleton(const DynamicContext::Ptr &context) const;

    85     };

    86 

    87     /**

    88      * @short Implements the function <tt>fn:string-join()</tt>.

    89      *

    90      * @ingroup Patternist_functions

    91      * @author Frans Englich <frans.englich@nokia.com>

    92      */

    93     class StringJoinFN : public FunctionCall

    94     {

    95     public:

    96         virtual Item evaluateSingleton(const DynamicContext::Ptr &context) const;

    97 

    98         /**

    99          * Optimization: when the cardinality of the sequence of items to join

   100          * cannot be two or more, we have no effect and therefore rewrite

   101          * ourselves to our first operand.

   102          */

   103         virtual Expression::Ptr compress(const StaticContext::Ptr &context);

   104     };

   105 

   106     /**

   107      * @short Implements the function <tt>fn:substring()</tt>.

   108      *

   109      * @ingroup Patternist_functions

   110      * @author Frans Englich <frans.englich@nokia.com>

   111      */

   112     class SubstringFN : public FunctionCall

   113     {

   114     public:

   115         virtual Item evaluateSingleton(const DynamicContext::Ptr &context) const;

   116     };

   117 

   118     /**

   119      * @short Implements the function <tt>fn:string-length()</tt>.

   120      *

   121      * @ingroup Patternist_functions

   122      * @author Frans Englich <frans.englich@nokia.com>

   123      */

   124     class StringLengthFN : public FunctionCall

   125     {

   126     public:

   127         virtual Item evaluateSingleton(const DynamicContext::Ptr &context) const;

   128     };

   129 

   130     /**

   131      * @short Implements the function <tt>fn:normalize-space()</tt>.

   132      *

   133      * @ingroup Patternist_functions

   134      * @author Frans Englich <frans.englich@nokia.com>

   135      */

   136     class NormalizeSpaceFN : public FunctionCall

   137     {

   138     public:

   139         virtual Item evaluateSingleton(const DynamicContext::Ptr &context) const;

   140     };

   141 

   142     /**

   143      * @short Implements the function <tt>fn:normalize-unicode()</tt>.

   144      *

   145      * What perhaps can be said significant with the implementation, is that it

   146      * attempts to determine the normalization form at compile time, in order to

   147      * reduce string work at runtime.

   148      *

   149      * @ingroup Patternist_functions

   150      * @author Frans Englich <frans.englich@nokia.com>

   151      */

   152     class NormalizeUnicodeFN : public FunctionCall

   153     {

   154     public:

   155         /**

   156          * Initializes private data.

   157          */

   158         NormalizeUnicodeFN();

   159         virtual Item evaluateSingleton(const DynamicContext::Ptr &context) const;

   160         virtual Expression::Ptr compress(const StaticContext::Ptr &context);

   161 

   162     private:

   163         int determineNormalizationForm(const DynamicContext::Ptr &context) const;

   164         QString::NormalizationForm m_normForm;

   165     };

   166 

   167     /**

   168      * @short Implements the function <tt>fn:upper-case()</tt>.

   169      *

   170      * @ingroup Patternist_functions

   171      * @author Frans Englich <frans.englich@nokia.com>

   172      */

   173     class UpperCaseFN : public FunctionCall

   174     {

   175     public:

   176         virtual Item evaluateSingleton(const DynamicContext::Ptr &context) const;

   177     };

   178 

   179     /**

   180      * @short Implements the function <tt>fn:lower-case()</tt>.

   181      *

   182      * @short Implements the function <tt>fn:concat()</tt>.

   183      * @ingroup Patternist_functions

   184      * @author Frans Englich <frans.englich@nokia.com>

   185      */

   186     class LowerCaseFN : public FunctionCall

   187     {

   188     public:

   189         virtual Item evaluateSingleton(const DynamicContext::Ptr &context) const;

   190     };

   191 

   192     /**

   193      * @short Implements the function <tt>fn:translate()</tt>.

   194      *

   195      * @ingroup Patternist_functions

   196      * @author Frans Englich <frans.englich@nokia.com>

   197      */

   198     class TranslateFN : public FunctionCall

   199     {

   200     public:

   201         virtual Item evaluateSingleton(const DynamicContext::Ptr &context) const;

   202     };

   203 

   204     /**

   205      * @short Provides functionality for encoding strings. Sub-classed by various

   206      * function implementations.

   207      *

   208      * @ingroup Patternist_functions

   209      * @author Frans Englich <frans.englich@nokia.com>

   210      */

   211     class EncodeString : public FunctionCall

   212     {

   213     public:

   214         /**

   215          * Evaluates its first operand. If it is the empty sequence, an empty string

   216          * is returned. Otherwise, the item's string value is returned percent encoded

   217          * as specified in this class's constructor.

   218          */

   219         virtual Item evaluateSingleton(const DynamicContext::Ptr &context) const;

   220 

   221     protected:

   222         /**

   223          * Encodes its operand with QUrl::toPercentEncoding(), with @p includeChars as

   224          * the characters to encode, and @p excludeChars as the characters to not encode.

   225          */

   226         EncodeString(const QByteArray &excludeChars, const QByteArray &includeChars);

   227 

   228     private:

   229         const QByteArray m_excludeChars;

   230         const QByteArray m_includeChars;

   231     };

   232 

   233     /**

   234      * @short Implements the function <tt>fn:encode-for-uri()</tt>.

   235      *

   236      * @ingroup Patternist_functions

   237      * @author Frans Englich <frans.englich@nokia.com>

   238      */

   239     class EncodeForURIFN : public EncodeString

   240     {

   241     public:

   242         /**

   243          * Performs internal initialization.

   244          */

   245         EncodeForURIFN();

   246 

   247     private:

   248         static const char *const include;

   249     };

   250 

   251     /**

   252      * @short Implements the function <tt>fn:iri-to-uri()</tt>.

   253      *

   254      * @ingroup Patternist_functions

   255      * @author Frans Englich <frans.englich@nokia.com>

   256      */

   257     class IriToURIFN : public EncodeString

   258     {

   259     public:

   260         /**

   261          * Performs internal initialization.

   262          */

   263         IriToURIFN();

   264 

   265     private:

   266         static const char *const exclude;

   267     };

   268 

   269     /**

   270      * @short Implements the function <tt>fn:escape-html-uri()</tt>.

   271      *

   272      * @ingroup Patternist_functions

   273      * @author Frans Englich <frans.englich@nokia.com>

   274      */

   275     class EscapeHtmlURIFN : public EncodeString

   276     {

   277     public:

   278         /**

   279          * Performs internal initialization.

   280          */

   281         EscapeHtmlURIFN();

   282 

   283     private:

   284         static const char *const include;

   285         static const char *const exclude;

   286     };

   287 }

   288 

   289 QT_END_NAMESPACE

   290 

   291 QT_END_HEADER

   292 

   293 #endif