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 #include <qnumeric.h>

    43 

    44 #include "qabstractfloat_p.h"

    45 #include "qanyuri_p.h"

    46 #include "qbase64binary_p.h"

    47 #include "qboolean_p.h"

    48 #include "qcommonvalues_p.h"

    49 #include "qdate_p.h"

    50 #include "qschemadatetime_p.h"

    51 #include "qdaytimeduration_p.h"

    52 #include "qdecimal_p.h"

    53 #include "qduration_p.h"

    54 #include "qgday_p.h"

    55 #include "qgmonth_p.h"

    56 #include "qgmonthday_p.h"

    57 #include "qgyear_p.h"

    58 #include "qgyearmonth_p.h"

    59 #include "qhexbinary_p.h"

    60 #include "qinteger_p.h"

    61 #include "qatomicstring_p.h"

    62 #include "qschematime_p.h"

    63 #include "quntypedatomic_p.h"

    64 #include "qyearmonthduration_p.h"

    65 

    66 #include "qatomiccasters_p.h"

    67 

    68 QT_BEGIN_NAMESPACE

    69 

    70 using namespace QPatternist;

    71 

    72 Item ToUntypedAtomicCaster::castFrom(const Item &from,

    73                                      const QExplicitlySharedDataPointer<DynamicContext> &) const

    74 {

    75     return UntypedAtomic::fromValue(from.stringValue());

    76 }

    77 

    78 Item ToAnyURICaster::castFrom(const Item &from,

    79                               const QExplicitlySharedDataPointer<DynamicContext> &) const

    80 {

    81     return toItem(AnyURI::fromLexical(from.stringValue()));

    82 }

    83 

    84 Item Base64BinaryToHexBinaryCaster::castFrom(const Item &from,

    85                                              const QExplicitlySharedDataPointer<DynamicContext> &) const

    86 {

    87     return HexBinary::fromValue(from.as<Base64Binary>()->asByteArray());

    88 }

    89 

    90 Item StringToHexBinaryCaster::castFrom(const Item &from,

    91                                        const QExplicitlySharedDataPointer<DynamicContext> &context) const

    92 {

    93     return HexBinary::fromLexical(context->namePool(), from.stringValue());

    94 }

    95 

    96 Item HexBinaryToBase64BinaryCaster::castFrom(const Item &from,

    97                                              const QExplicitlySharedDataPointer<DynamicContext> &) const

    98 {

    99     return Base64Binary::fromValue(from.as<Base64Binary>()->asByteArray());

   100 }

   101 

   102 Item StringToBase64BinaryCaster::castFrom(const Item &from,

   103                                           const QExplicitlySharedDataPointer<DynamicContext> &) const

   104 {

   105     return Base64Binary::fromLexical(from.stringValue());

   106 }

   107 

   108 Item NumericToBooleanCaster::castFrom(const Item &from,

   109                                       const QExplicitlySharedDataPointer<DynamicContext> &) const

   110 {

   111     const xsDouble val = from.as<Numeric>()->toDouble();

   112     if(Double::isEqual(val, 0.0) || qIsNaN(val))

   113         return CommonValues::BooleanFalse;

   114     else

   115         return CommonValues::BooleanTrue;

   116 }

   117 

   118 Item StringToBooleanCaster::castFrom(const Item &from,

   119                                      const QExplicitlySharedDataPointer<DynamicContext> &) const

   120 {

   121     return Boolean::fromLexical(from.stringValue());

   122 }

   123 

   124 Item StringToDecimalCaster::castFrom(const Item &from,

   125                                      const QExplicitlySharedDataPointer<DynamicContext> &) const

   126 {

   127     return Decimal::fromLexical(from.stringValue());

   128 }

   129 

   130 Item StringToIntegerCaster::castFrom(const Item &from,

   131                                      const QExplicitlySharedDataPointer<DynamicContext> &) const

   132 {

   133     return Integer::fromLexical(from.stringValue());

   134 }

   135 

   136 Item BooleanToDecimalCaster::castFrom(const Item &from,

   137                                       const QExplicitlySharedDataPointer<DynamicContext> &context) const

   138 {

   139     if(from.as<AtomicValue>()->evaluateEBV(context))

   140         return CommonValues::DecimalOne;

   141     else

   142         return CommonValues::DecimalZero;

   143 }

   144 

   145 Item BooleanToIntegerCaster::castFrom(const Item &from,

   146                                       const QExplicitlySharedDataPointer<DynamicContext> &context) const

   147 {

   148     if(from.as<AtomicValue>()->evaluateEBV(context))

   149         return CommonValues::IntegerOne;

   150     else

   151         return CommonValues::IntegerZero;

   152 }

   153 

   154 Item SelfToSelfCaster::castFrom(const Item &from,

   155                                 const QExplicitlySharedDataPointer<DynamicContext> &) const

   156 {

   157     return from;

   158 }

   159 

   160 Item StringToGYearCaster::castFrom(const Item &from,

   161                                    const QExplicitlySharedDataPointer<DynamicContext> &) const

   162 {

   163     return GYear::fromLexical(from.stringValue());

   164 }

   165 

   166 Item StringToGDayCaster::castFrom(const Item &from,

   167                                   const QExplicitlySharedDataPointer<DynamicContext> &) const

   168 {

   169     return GDay::fromLexical(from.stringValue());

   170 }

   171 

   172 Item StringToGMonthCaster::castFrom(const Item &from,

   173                                     const QExplicitlySharedDataPointer<DynamicContext> &) const

   174 {

   175     return GMonth::fromLexical(from.stringValue());

   176 }

   177 

   178 Item StringToGYearMonthCaster::castFrom(const Item &from,

   179                                         const QExplicitlySharedDataPointer<DynamicContext> &) const

   180 {

   181     return GYearMonth::fromLexical(from.stringValue());

   182 }

   183 

   184 Item StringToGMonthDayCaster::castFrom(const Item &from,

   185                                        const QExplicitlySharedDataPointer<DynamicContext> &) const

   186 {

   187     return GMonthDay::fromLexical(from.stringValue());

   188 }

   189 

   190 Item StringToDateTimeCaster::castFrom(const Item &from,

   191                                       const QExplicitlySharedDataPointer<DynamicContext> &) const

   192 {

   193     return DateTime::fromLexical(from.stringValue());

   194 }

   195 

   196 Item StringToTimeCaster::castFrom(const Item &from,

   197                                   const QExplicitlySharedDataPointer<DynamicContext> &) const

   198 {

   199     return SchemaTime::fromLexical(from.stringValue());

   200 }

   201 

   202 Item StringToDateCaster::castFrom(const Item &from,

   203                                   const QExplicitlySharedDataPointer<DynamicContext> &) const

   204 {

   205     return Date::fromLexical(from.stringValue());

   206 }

   207 

   208 Item StringToDurationCaster::castFrom(const Item &from,

   209                                       const QExplicitlySharedDataPointer<DynamicContext> &) const

   210 {

   211     return Duration::fromLexical(from.stringValue());

   212 }

   213 

   214 Item StringToDayTimeDurationCaster::castFrom(const Item &from,

   215                                              const QExplicitlySharedDataPointer<DynamicContext> &) const

   216 {

   217     return toItem(DayTimeDuration::fromLexical(from.stringValue()));

   218 }

   219 

   220 Item AbstractDurationToDayTimeDurationCaster::castFrom(const Item &from,

   221                                                        const QExplicitlySharedDataPointer<DynamicContext> &) const

   222 {

   223     const AbstractDuration *const val = from.as<AbstractDuration>();

   224 

   225     return toItem(DayTimeDuration::fromComponents(val->isPositive(),

   226                                                   val->days(),

   227                                                   val->hours(),

   228                                                   val->minutes(),

   229                                                   val->seconds(),

   230                                                   val->mseconds()));

   231 }

   232 

   233 Item AbstractDurationToYearMonthDurationCaster::castFrom(const Item &from,

   234                                                          const QExplicitlySharedDataPointer<DynamicContext> &) const

   235 {

   236     const AbstractDuration *const val = from.as<AbstractDuration>();

   237 

   238     return toItem(YearMonthDuration::fromComponents(val->isPositive(),

   239                                                     val->years(),

   240                                                     val->months()));

   241 }

   242 

   243 Item AbstractDurationToDurationCaster::castFrom(const Item &from,

   244                                                 const QExplicitlySharedDataPointer<DynamicContext> &) const

   245 {

   246     const AbstractDuration *const val = from.as<AbstractDuration>();

   247 

   248     return Duration::fromComponents(val->isPositive(),

   249                                     val->years(),

   250                                     val->months(),

   251                                     val->days(),

   252                                     val->hours(),

   253                                     val->minutes(),

   254                                     val->seconds(),

   255                                     val->mseconds());

   256 }

   257 

   258 Item StringToYearMonthDurationCaster::castFrom(const Item &from,

   259                                                const QExplicitlySharedDataPointer<DynamicContext> &) const

   260 {

   261     return YearMonthDuration::fromLexical(from.stringValue());

   262 }

   263 

   264 Item AbstractDateTimeToGYearCaster::castFrom(const Item &from,

   265                                              const QExplicitlySharedDataPointer<DynamicContext> &) const

   266 {

   267     QDateTime dt(from.as<AbstractDateTime>()->toDateTime());

   268     // TODO DT dt.setDateOnly(true);

   269 

   270     return GYear::fromDateTime(dt);

   271 }

   272 

   273 Item AbstractDateTimeToGYearMonthCaster::castFrom(const Item &from,

   274                                                   const QExplicitlySharedDataPointer<DynamicContext> &) const

   275 {

   276     QDateTime dt(from.as<AbstractDateTime>()->toDateTime());

   277     // TODO DT dt.setDateOnly(true);

   278 

   279     return GYearMonth::fromDateTime(dt);

   280 }

   281 

   282 Item AbstractDateTimeToGMonthCaster::castFrom(const Item &from,

   283                                               const QExplicitlySharedDataPointer<DynamicContext> &) const

   284 {

   285     QDateTime dt(from.as<AbstractDateTime>()->toDateTime());

   286     // TODO DT dt.setDateOnly(true);

   287 

   288     return GMonth::fromDateTime(dt);

   289 }

   290 

   291 Item AbstractDateTimeToGMonthDayCaster::castFrom(const Item &from,

   292                                                  const QExplicitlySharedDataPointer<DynamicContext> &) const

   293 {

   294     QDateTime dt(from.as<AbstractDateTime>()->toDateTime());

   295     // TODO DT dt.setDateOnly(true);

   296 

   297     return GMonthDay::fromDateTime(dt);

   298 }

   299 

   300 Item AbstractDateTimeToGDayCaster::castFrom(const Item &from,

   301                                             const QExplicitlySharedDataPointer<DynamicContext> &) const

   302 {

   303     QDateTime dt(from.as<AbstractDateTime>()->toDateTime());

   304     // TODO DT dt.setDateOnly(true);

   305 

   306     return GDay::fromDateTime(dt);

   307 }

   308 

   309 Item AbstractDateTimeToDateTimeCaster::castFrom(const Item &from,

   310                                                 const QExplicitlySharedDataPointer<DynamicContext> &) const

   311 {

   312     QDateTime dt(from.as<AbstractDateTime>()->toDateTime());

   313     // TODO DT dt.setDateOnly(false);

   314 

   315     return DateTime::fromDateTime(dt);

   316 }

   317 

   318 Item AbstractDateTimeToDateCaster::castFrom(const Item &from,

   319                                             const QExplicitlySharedDataPointer<DynamicContext> &) const

   320 {

   321     QDateTime dt(from.as<AbstractDateTime>()->toDateTime());

   322     // TODO DT dt.setDateOnly(true);

   323 

   324     return Date::fromDateTime(dt);

   325 }

   326 

   327 Item AbstractDateTimeToTimeCaster::castFrom(const Item &from,

   328                                             const QExplicitlySharedDataPointer<DynamicContext> &) const

   329 {

   330     QDateTime dt(from.as<AbstractDateTime>()->toDateTime());

   331     // TODO DT dt.setDateOnly(false);

   332 

   333     return SchemaTime::fromDateTime(dt);

   334 }

   335 

   336 QT_END_NAMESPACE