开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > xml/soap/webservice > 查看源码
XMLDateTime.cpp
资源名称：xerces-c-src1_6_0.tar.gz　[点击查看]
上传用户：huihehuasu
上传日期：2007-01-10
资源大小：6948k
文件大小：36k
源码类别：

xml/soap/webservice

开发平台：

C/C++

XMLDateTime.cpp：源码内容
  1. /*
  2.  * The Apache Software License, Version 1.1
  3.  *
  4.  * Copyright (c) 2001 The Apache Software Foundation.  All rights
  5.  * reserved.
  6.  *
  7.  * Redistribution and use in source and binary forms, with or without
  8.  * modification, are permitted provided that the following conditions
  9.  * are met:
  10.  *
  11.  * 1. Redistributions of source code must retain the above copyright
  12.  *    notice, this list of conditions and the following disclaimer.
  13.  *
  14.  * 2. Redistributions in binary form must reproduce the above copyright
  15.  *    notice, this list of conditions and the following disclaimer in
  16.  *    the documentation and/or other materials provided with the
  17.  *    distribution.
  18.  *
  19.  * 3. The end-user documentation included with the redistribution,
  20.  *    if any, must include the following acknowledgment:
  21.  *       "This product includes software developed by the
  22.  *        Apache Software Foundation (http://www.apache.org/)."
  23.  *    Alternately, this acknowledgment may appear in the software itself,
  24.  *    if and wherever such third-party acknowledgments normally appear.
  25.  *
  26.  * 4. The names "Xerces" and "Apache Software Foundation" must
  27.  *    not be used to endorse or promote products derived from this
  28.  *    software without prior written permission. For written
  29.  *    permission, please contact apache@apache.org.
  30.  *
  31.  * 5. Products derived from this software may not be called "Apache",
  32.  *    nor may "Apache" appear in their name, without prior written
  33.  *    permission of the Apache Software Foundation.
  34.  *
  35.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
  36.  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  37.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  38.  * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
  39.  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  40.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  41.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  42.  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  43.  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  44.  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  45.  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  46.  * SUCH DAMAGE.
  47.  * ====================================================================
  48.  *
  49.  * This software consists of voluntary contributions made by many
  50.  * individuals on behalf of the Apache Software Foundation, and was
  51.  * originally based on software copyright (c) 2001, International
  52.  * Business Machines, Inc., http://www.ibm.com .  For more information
  53.  * on the Apache Software Foundation, please see
  54.  * <http://www.apache.org/>.
  55.  */
  57. /*
  58.  * $Id: XMLDateTime.cpp,v 1.4 2001/11/14 22:04:03 peiyongz Exp $
  59.  * $Log: XMLDateTime.cpp,v $
  60.  * Revision 1.4  2001/11/14 22:04:03  peiyongz
  61.  * Patch to apply check on Year and more rigorous on other fields as well.
  62.  *
  63.  * Revision 1.3  2001/11/12 20:36:54  peiyongz
  64.  * SchemaDateTimeException defined
  65.  *
  66.  * Revision 1.2  2001/11/09 20:41:45  peiyongz
  67.  * Fix: compilation error on Solaris and AIX.
  68.  *
  69.  * Revision 1.1  2001/11/07 19:16:03  peiyongz
  70.  * DateTime Port
  71.  *
  72.  *
  73.  */
  75. // ---------------------------------------------------------------------------
  76. //  Includes
  77. // ---------------------------------------------------------------------------
  78. #include <stdlib.h>
  79. #include <util/XMLDateTime.hpp>
  80. #include <util/XMLString.hpp>
  81. #include <util/XMLUni.hpp>
  82. #include <util/Janitor.hpp>
  84. //
  85. // constants used to process raw data (fBuffer)
  86. //
  87. // [-]{CCYY-MM-DD}'T'{HH:MM:SS.MS}['Z']
  88. //                                [{+|-}hh:mm']
  89. //                                  
  91. static const XMLCh DURATION_STARTER     = chLatin_P;              // 'P'
  92. static const XMLCh DURATION_Y           = chLatin_Y;              // 'Y'
  93. static const XMLCh DURATION_M           = chLatin_M;              // 'M'
  94. static const XMLCh DURATION_D           = chLatin_D;              // 'D'
  95. static const XMLCh DURATION_H           = chLatin_H;              // 'H'
  96. static const XMLCh DURATION_S           = chLatin_S;              // 'S'
  98. static const XMLCh DATE_SEPARATOR       = chDash;                 // '-'
  99. static const XMLCh TIME_SEPARATOR       = chColon;                // ':'
  100. static const XMLCh TIMEZONE_SEPARATOR   = chColon;                // ':'
  101. static const XMLCh DATETIME_SEPARATOR   = chLatin_T;              // 'T'
  102. static const XMLCh MILISECOND_SEPARATOR = chPeriod;               // '.'
  104. static const XMLCh UTC_STD_CHAR         = chLatin_Z;              // 'Z'
  105. static const XMLCh UTC_POS_CHAR         = chPlus;                 // '+'
  106. static const XMLCh UTC_NEG_CHAR         = chDash;                 // '-'
  108. static const XMLCh UTC_SET[]            = {UTC_STD_CHAR           //"Z+-"
  109.                                          , UTC_POS_CHAR
  110.                                          , UTC_NEG_CHAR
  111.                                          , chNull};
  113. static const int YMD_MIN_SIZE    = 10;   // CCYY-MM-DD
  114. static const int YMONTH_MIN_SIZE = 7;    // CCYY_MM
  115. static const int TIME_MIN_SIZE   = 8;    // hh:mm:ss
  116. static const int TIMEZONE_SIZE   = 5;    // hh:mm
  117. static const int DAY_SIZE        = 5;    // ---DD
  118. static const int MONTH_SIZE      = 6;    // --MM--
  119. static const int MONTHDAY_SIZE   = 7;    // --MM-DD
  120. static const int NOT_FOUND       = -1;   
  122. //define constants to be used in assigning default values for 
  123. //all date/time excluding duration
  124. static const int YEAR_DEFAULT  = 2000;
  125. static const int MONTH_DEFAULT = 01;
  126. static const int DAY_DEFAULT   = 15;
  128. // order-relation on duration is a partial order. The dates below are used to 
  129. // for comparison of 2 durations, based on the fact that
  130. // duration x and y is x<=y iff s+x<=s+y
  131. // see 3.2.6 duration W3C schema datatype specs
  132. //
  133. // the dates are in format: {CCYY,MM,DD, H, S, M, MS, timezone}  
  134. static const int DATETIMES[][XMLDateTime::TOTAL_SIZE] = 
  135. {
  136.     {1696, 9, 1, 0, 0, 0, 0, XMLDateTime::UTC_STD},     
  137. {1697, 2, 1, 0, 0, 0, 0, XMLDateTime::UTC_STD},
  138. {1903, 3, 1, 0, 0, 0, 0, XMLDateTime::UTC_STD},
  139. {1903, 7, 1, 0, 0, 0, 0, XMLDateTime::UTC_STD}
  140. };
  142. // ---------------------------------------------------------------------------
  143. //  local methods
  144. // ---------------------------------------------------------------------------
  145. static inline int fQuotient(int a, int b)
  146. {
  147.     div_t div_result = div(a, b);
  148.     return div_result.quot;
  149. }
  151. static inline int fQuotient(int temp, int low, int high) 
  152. {
  153.     return fQuotient(temp - low, high - low);
  154. }
  156. static inline int mod(int a, int b, int quotient) 
  157. {
  158. return (a - quotient*b) ;
  159. }
  161. static inline int modulo (int temp, int low, int high) 
  162. {
  163.     //modulo(a - low, high - low) + low 
  164.     int a = temp - low;
  165.     int b = high - low;
  166.     return (mod (a, b, fQuotient(a, b)) + low) ;
  167. }
  169. static inline bool isLeapYear(int year)
  170. {
  171.     return((year%4 == 0) && ((year%100 != 0) || (year%400 == 0))); 
  172. }
  174. static int maxDayInMonthFor(int year, int month) 
  175. {
  177.     if ( month == 4 || month == 6 || month == 9 || month == 11 ) 
  178.     {
  179.         return 30;
  180.     }
  181.     else if ( month==2 ) 
  182.     {
  183.         if ( isLeapYear(year) ) 
  184.             return 29;
  185.         else 
  186.             return 28;
  187.     }
  188.     else
  189.     {
  190.         return 31;
  191.     }
  193. }
  195. // ---------------------------------------------------------------------------
  196. //  static methods : for duration
  197. // ---------------------------------------------------------------------------
  198. /**
  199.  * Compares 2 given durations. (refer to W3C Schema Datatypes "3.2.6 duration")
  200.  *
  201.  * 3.2.6.2 Order relation on duration
  202.  *
  203.  *     In general, the order-relation on duration is a partial order since there is no 
  204.  *  determinate relationship between certain durations such as one month (P1M) and 30 days (P30D). 
  205.  *  The order-relation of two duration values x and y is x < y iff s+x < s+y for each qualified 
  206.  *  dateTime s in the list below. 
  207.  *
  208.  *     These values for s cause the greatest deviations in the addition of dateTimes and durations
  209.  * 
  210.  **/
  211. int XMLDateTime::compare(const XMLDateTime* const pDate1
  212.                        , const XMLDateTime* const pDate2
  213.                        , bool  strict)
  214. {
  215.     //REVISIT: this is unoptimazed vs of comparing 2 durations
  216.     //         Algorithm is described in 3.2.6.2 W3C Schema Datatype specs
  217.     //
  219.     int resultA, resultB = INDETERMINATE;
  221.     //try and see if the objects are equal
  222.     if ( (resultA = compareOrder(pDate1, pDate2)) == EQUAL)
  223.         return EQUAL;
  225.     //long comparison algorithm is required
  226.     XMLDateTime tempA, *pTempA = &tempA;
  227.     XMLDateTime tempB, *pTempB = &tempB;
  229.     addDuration(pTempA, pDate1, 0);
  230.     addDuration(pTempB, pDate2, 0);
  231.     resultA = compareOrder(pTempA, pTempB);
  232.     if ( resultA == INDETERMINATE )  
  233.         return INDETERMINATE;
  235.     addDuration(pTempA, pDate1, 1);
  236.     addDuration(pTempB, pDate2, 1);
  237.     resultB = compareOrder(pTempA, pTempB);
  238.     resultA = compareResult(resultA, resultB, strict);
  239.     if ( resultA == INDETERMINATE ) 
  240.         return INDETERMINATE;
  242.     addDuration(pTempA, pDate1, 2);
  243.     addDuration(pTempB, pDate2, 2);
  244.     resultB = compareOrder(pTempA, pTempB);
  245.     resultA = compareResult(resultA, resultB, strict);
  246.     if ( resultA == INDETERMINATE )
  247.         return INDETERMINATE;
  249.     addDuration(pTempA, pDate1, 3);
  250.     addDuration(pTempB, pDate2, 3);
  251.     resultB = compareOrder(pTempA, pTempB);
  252.     resultA = compareResult(resultA, resultB, strict);
  254.     return resultA;
  256. }
  258. //
  259. // Form a new XMLDateTime with duration and baseDate array
  260. // Note: C++        Java
  261. //       fNewDate   duration
  262. //       fDuration  date
  263. //
  265. void XMLDateTime::addDuration(XMLDateTime*             fNewDate 
  266.                             , const XMLDateTime* const fDuration
  267.                             , int index)
  269. {
  271.     //REVISIT: some code could be shared between normalize() and this method,
  272.     //         however is it worth moving it? The structures are different...
  273.     //
  275.     fNewDate->reset();
  276.     //add months (may be modified additionaly below)
  277.     int temp = DATETIMES[index][Month] + fDuration->fValue[Month];
  278.     fNewDate->fValue[Month] = modulo(temp, 1, 13);
  279.     int carry = fQuotient(temp, 1, 13);
  281.     //add years (may be modified additionaly below)
  282.     fNewDate->fValue[CentYear] = DATETIMES[index][CentYear] + fDuration->fValue[CentYear] + carry;
  284.     //add seconds
  285.     temp = DATETIMES[index][Second] + fDuration->fValue[Second];
  286.     carry = fQuotient (temp, 60);
  287.     fNewDate->fValue[Second] =  mod(temp, 60, carry);
  289.     //add minutes 
  290.     temp = DATETIMES[index][Minute] + fDuration->fValue[Minute] + carry; 
  291.     carry = fQuotient(temp, 60); 
  292.     fNewDate->fValue[Minute] = mod(temp, 60, carry);         
  294.     //add hours
  295.     temp = DATETIMES[index][Hour] + fDuration->fValue[Hour] + carry;
  296.     carry = fQuotient(temp, 24);
  297.     fNewDate->fValue[Hour] = mod(temp, 24, carry);
  299.     fNewDate->fValue[Day] = DATETIMES[index][Day] + fDuration->fValue[Day] + carry;
  301.     while ( true ) 
  302.     {
  303.         temp = maxDayInMonthFor(fNewDate->fValue[CentYear], fNewDate->fValue[Month]);
  304.         if ( fNewDate->fValue[Day] < 1 ) 
  305.         { //original fNewDate was negative
  306.             fNewDate->fValue[Day] += maxDayInMonthFor(fNewDate->fValue[CentYear], fNewDate->fValue[Month]-1);
  307.             carry = -1;
  308.         }
  309.         else if ( fNewDate->fValue[Day] > temp ) 
  310.         {
  311.             fNewDate->fValue[Day] -= temp;
  312.             carry = 1;
  313.         }
  314.         else 
  315.         {
  316.             break;
  317.         }
  319.         temp = fNewDate->fValue[Month] + carry;
  320.         fNewDate->fValue[Month] = modulo(temp, 1, 13);
  321.         fNewDate->fValue[CentYear] += fQuotient(temp, 1, 13);
  322.     }
  324.     //fNewDate->fValue[utc] = UTC_STD_CHAR;
  325.     fNewDate->fValue[utc] = UTC_STD;
  326. }
  328. int XMLDateTime::compareResult(short resultA
  329.                              , short resultB
  330.                              , bool strict)
  331. {
  333.     if ( resultB == INDETERMINATE ) 
  334.     {
  335.         return INDETERMINATE;
  336.     }
  337.     else if ( (resultA != resultB) && 
  338.               strict                ) 
  339.     {
  340.         return INDETERMINATE;
  341.     }
  342.     else if ( (resultA != resultB) && 
  343.               !strict               ) 
  344.     {
  345.         if ( (resultA != EQUAL) && 
  346.              (resultB != EQUAL)  ) 
  347.         {
  348.             return INDETERMINATE;
  349.         }
  350.         else 
  351.         {
  352.             return (resultA != EQUAL)? resultA : resultB;
  353.         }
  354.     }
  356.     return resultA;
  358. }
  360. // ---------------------------------------------------------------------------
  361. //  static methods : for others
  362. // ---------------------------------------------------------------------------
  363. int XMLDateTime::compare(const XMLDateTime* const pDate1
  364.                        , const XMLDateTime* const pDate2)
  365. {
  367.     if (pDate1->fValue[utc] == pDate2->fValue[utc])
  368.     {
  369.         return XMLDateTime::compareOrder(pDate1, pDate2);    
  370.     }
  372.     short c1, c2;
  374.     if ( pDate1->isNormalized()) 
  375.     {
  376.         c1 = compareResult(pDate1, pDate2, false, UTC_POS);
  377.         c2 = compareResult(pDate1, pDate2, false, UTC_NEG);
  378.         return getRetVal(c1, c2);
  379.     }
  380.     else if ( pDate2->isNormalized()) 
  381.     {
  382.         c1 = compareResult(pDate1, pDate2, true, UTC_POS);
  383.         c2 = compareResult(pDate1, pDate2, true, UTC_NEG);
  384.         return getRetVal(c1, c2);
  385.     }
  387.     return INDETERMINATE;
  388. }
  390. int XMLDateTime::compareResult(const XMLDateTime* const pDate1
  391.                              , const XMLDateTime* const pDate2
  392.                              , bool  set2Left
  393.                              , int   utc_type)
  394. {
  395.     XMLDateTime tmpDate = (set2Left ? *pDate1 : *pDate2);
  397.     tmpDate.fTimeZone[hh] = 14;
  398.     tmpDate.fTimeZone[mm] = 0;
  399.     tmpDate.fValue[utc] = utc_type;
  400.     tmpDate.normalize();
  402.     return (set2Left? XMLDateTime::compareOrder(&tmpDate, pDate2) :
  403.                       XMLDateTime::compareOrder(pDate1, &tmpDate));
  404. }
  406. int XMLDateTime::compareOrder(const XMLDateTime* const lValue
  407.                             , const XMLDateTime* const rValue)
  408. {  
  409.     //
  410.     // If any of the them is not normalized() yet, 
  411.     // we need to do something here.
  412.     //
  413.     XMLDateTime lTemp = *lValue;
  414.     XMLDateTime rTemp = *rValue;
  416.     lTemp.normalize();
  417.     rTemp.normalize();
  419.     for ( int i = 0 ; i < TOTAL_SIZE; i++ ) 
  420.     {
  421.         if ( lTemp.fValue[i] < rTemp.fValue[i] ) 
  422.         {
  423.             return LESS_THAN;
  424.         }
  425.         else if ( lTemp.fValue[i] > rTemp.fValue[i] ) 
  426.         {
  427.             return GREATER_THAN;
  428.         }
  429.     }
  431.     return EQUAL;
  432. }
  434. // ---------------------------------------------------------------------------
  435. //  ctor and dtor
  436. // ---------------------------------------------------------------------------
  437. XMLDateTime::~XMLDateTime()
  438. {
  439.     if (fBuffer)
  440.         delete[] fBuffer;
  441. }
  443. XMLDateTime::XMLDateTime()
  444. :fBuffer(0)
  445. {
  446.     reset();
  447. }
  449. XMLDateTime::XMLDateTime(const XMLCh* const aString)
  450. :fBuffer(0)
  451. {
  452.     setBuffer(aString);
  453. }
  455. // -----------------------------------------------------------------------
  456. // Copy ctor and Assignment operators
  457. // -----------------------------------------------------------------------
  459. XMLDateTime::XMLDateTime(const XMLDateTime &toCopy)
  460. :fBuffer(0)
  461. {
  462.     copy(toCopy);
  463. }
  465. XMLDateTime& XMLDateTime::operator=(const XMLDateTime& rhs)
  466. {
  467.     if (this == &rhs)
  468.         return *this;
  470.     copy(rhs);
  471.     return *this;
  472. }
  474. // -----------------------------------------------------------------------
  475. // Implementation of Abstract Interface
  476. // -----------------------------------------------------------------------
  478. //
  479. // We may simply return the handle to fBuffer, but
  480. // for the sake of consistency, we return a duplicated copy 
  481. // and the caller is responsible for the release of the buffer
  482. // just like any other things in the XMLNumber family.
  483. //
  484. XMLCh*  XMLDateTime::toString() const
  485. {
  486.     assertBuffer();
  488.     XMLCh* retBuf = XMLString::replicate(fBuffer);
  489.     return retBuf;
  490. }
  492. int XMLDateTime::getSign() const
  493. {
  494.     return 0;
  495. }
  497. // ---------------------------------------------------------------------------
  498. //  Parsers
  499. // ---------------------------------------------------------------------------
  501. //
  502. // [-]{CCYY-MM-DD}'T'{HH:MM:SS.MS}[TimeZone]
  503. //
  504. void XMLDateTime::parseDateTime()
  505. {
  506.     initParser();
  507.     getDate();
  509.     //fStart is supposed to point to 'T'
  510.     if (fBuffer[fStart++] != DATETIME_SEPARATOR)
  511.         ThrowXML1(SchemaDateTimeException
  512.                 , XMLExcepts::DateTime_dt_missingT
  513.                 , fBuffer);
  515.     getTime();
  516.     validateDateTime();
  517.     normalize();
  518. }
  520. //
  521. // [-]{CCYY-MM-DD}[TimeZone]
  522. //
  523. void XMLDateTime::parseDate()
  524. {
  525.     initParser();
  526.     getDate();
  527.     parseTimeZone();
  528.     validateDateTime();
  529.     normalize();
  530. }
  532. void XMLDateTime::parseTime()
  533. {
  534.     initParser();
  536.     // time initialize to default values
  537.     fValue[CentYear]= YEAR_DEFAULT;
  538.     fValue[Month]   = MONTH_DEFAULT;
  539.     fValue[Day]     = DAY_DEFAULT;
  541.     getTime();
  543.     validateDateTime();
  544.     normalize();
  545. }
  547. //
  548. // {---DD}[TimeZone]
  549. //  01234
  550. //
  551. void XMLDateTime::parseDay()
  552. {
  553.     initParser();
  555.     if (fBuffer[0] != DATE_SEPARATOR || 
  556.         fBuffer[1] != DATE_SEPARATOR || 
  557.         fBuffer[2] != DATE_SEPARATOR  ) 
  558.     {
  559.         ThrowXML1(SchemaDateTimeException
  560.                 , XMLExcepts::DateTime_gDay_invalid
  561.                 , fBuffer);
  562.     }
  564.     //initialize values 
  565.     fValue[CentYear] = YEAR_DEFAULT;
  566.     fValue[Month]    = MONTH_DEFAULT;  
  567.     fValue[Day]      = parseInt(fStart+3, fStart+5);
  569.     if ( DAY_SIZE < fEnd ) 
  570.     {
  571.         int sign = findUTCSign(DAY_SIZE);
  572.         if ( sign < 0 ) 
  573.         {
  574.             ThrowXML1(SchemaDateTimeException
  575.                     , XMLExcepts::DateTime_gDay_invalid
  576.                     , fBuffer);
  577.         }
  578.         else 
  579.         {
  580.             getTimeZone(sign);
  581.         }
  582.     }
  584.     validateDateTime();
  585.     normalize();
  586. }
  588. //
  589. // {--MM--}[TimeZone]
  590. //  012345
  591. //
  592. void XMLDateTime::parseMonth()
  593. {
  594.     initParser();
  596.     if (fBuffer[0] != DATE_SEPARATOR || 
  597.         fBuffer[1] != DATE_SEPARATOR || 
  598.         fBuffer[4] != DATE_SEPARATOR ||
  599.         fBuffer[5] != DATE_SEPARATOR  )
  600.     {
  601.         ThrowXML1(SchemaDateTimeException
  602.                 , XMLExcepts::DateTime_gMth_invalid
  603.                 , fBuffer);
  604.     }
  606.     //set constants
  607.     fValue[CentYear] = YEAR_DEFAULT;
  608.     fValue[Day]      = DAY_DEFAULT;
  609.     fValue[Month]    = parseInt(2, 4);
  611.     if ( MONTH_SIZE < fEnd ) 
  612.     {
  613.         int sign = findUTCSign(MONTH_SIZE);
  614.         if ( sign < 0 ) 
  615.         {
  616.             ThrowXML1(SchemaDateTimeException
  617.                     , XMLExcepts::DateTime_gMth_invalid
  618.                     , fBuffer);
  619.         }
  620.         else 
  621.         {
  622.             getTimeZone(sign);
  623.         }
  624.     }
  626.     validateDateTime();
  627.     normalize();
  628. }
  630. //
  631. //[-]{CCYY}[TimeZone]
  632. // 0  1234
  633. //
  634. void XMLDateTime::parseYear()
  635. {
  636.     initParser();
  638.     // skip the first '-' and search for timezone
  639.     //
  640.     int sign = findUTCSign((fBuffer[0] == chDash) ? 1 : 0);
  642.     if (sign == NOT_FOUND) 
  643.     {
  644.         fValue[CentYear] = parseIntYear(fEnd);
  645.     }
  646.     else 
  647.     {
  648.         fValue[CentYear] = parseIntYear(sign);
  649.         getTimeZone(sign);
  650.     }
  652.     //initialize values 
  653.     fValue[Month] = MONTH_DEFAULT;
  654.     fValue[Day]   = DAY_DEFAULT;   //java is 1
  656.     validateDateTime();
  657.     normalize();
  658. }
  660. //
  661. //{--MM-DD}[TimeZone]
  662. // 0123456
  663. //
  664. void XMLDateTime::parseMonthDay()
  665. {
  666.     initParser();
  668.     if (fBuffer[0] != DATE_SEPARATOR || 
  669.         fBuffer[1] != DATE_SEPARATOR || 
  670.         fBuffer[4] != DATE_SEPARATOR )
  671.     {
  672.         ThrowXML1(SchemaDateTimeException
  673.                 , XMLExcepts::DateTime_gMthDay_invalid
  674.                 , fBuffer);
  675.     }
  678.     //initialize 
  679.     fValue[CentYear] = YEAR_DEFAULT;
  680.     fValue[Month]    = parseInt(2, 4);
  681.     fValue[Day]      = parseInt(5, 7);
  683.     if ( MONTHDAY_SIZE < fEnd ) 
  684.     {
  685.         int sign = findUTCSign(MONTHDAY_SIZE);
  686.         if ( sign<0 ) 
  687.         {
  688.             ThrowXML1(SchemaDateTimeException
  689.                     , XMLExcepts::DateTime_gMthDay_invalid
  690.                     , fBuffer);
  691.         }
  692.         else 
  693.         {
  694.             getTimeZone(sign);
  695.         }
  696.     }
  698.     validateDateTime();
  699.     normalize();
  700. }
  702. void XMLDateTime::parseYearMonth()
  703. {
  704.     initParser();
  706.     // get date
  707.     getYearMonth();
  708.     fValue[Day] = DAY_DEFAULT;
  709.     parseTimeZone();
  711.     validateDateTime();
  712.     normalize();
  713. }
  715. //
  716. //PnYn MnDTnH nMnS: -P1Y2M3DT10H30M        
  717. //
  718. // [-]{'P'{[n'Y'][n'M'][n'D']['T'][n'H'][n'M'][n'S']}}
  719. //
  720. //  Note: the n above shall be >= 0
  721. //        if no time element found, 'T' shall be absent
  722. //
  723. void XMLDateTime::parseDuration()
  724. {
  725.     initParser();
  727.     // must start with '-' or 'P'
  728.     //
  729.     XMLCh c = fBuffer[fStart++];
  730.     if ( (c != DURATION_STARTER) && 
  731.          (c != chDash)            ) 
  732.     {
  733.         ThrowXML1(SchemaDateTimeException
  734.                 , XMLExcepts::DateTime_dur_Start_dashP
  735.                 , fBuffer);
  736.     }
  738.     // 'P' must ALWAYS be present in either case
  739.     if ( (c == chDash) && 
  740.          (fBuffer[fStart++]!= DURATION_STARTER ))
  741.     {
  742.         ThrowXML1(SchemaDateTimeException
  743.                 , XMLExcepts::DateTime_dur_noP
  744.                 , fBuffer);
  745.     }
  747.     // java code
  748.     //date[utc]=(c=='-')?'-':0;
  749.     //fValue[utc] = UTC_STD; 
  750.     fValue[utc] = (fBuffer[0] == chDash? UTC_NEG : UTC_STD);
  752.     int negate = ( fBuffer[0] == chDash ? -1 : 1);
  754.     // 
  755.     // No negative value is allowed after 'P'
  756.     //
  757.     // eg P-1234, invalid
  758.     //
  759.     if (indexOf(fStart, fEnd, chDash) != NOT_FOUND)
  760.     {
  761.         ThrowXML1(SchemaDateTimeException
  762.                 , XMLExcepts::DateTime_dur_DashNotFirst
  763.                 , fBuffer);
  764.     }
  766.     //at least one number and designator must be seen after P
  767.     bool designator = false;
  769.     int endDate = indexOf(fStart, fEnd, DATETIME_SEPARATOR); 
  770.     if ( endDate == NOT_FOUND ) 
  771.     {
  772.         endDate = fEnd;  // 'T' absent
  773.     }
  775.     //find 'Y'        
  776.     int end = indexOf(fStart, endDate, DURATION_Y);
  777.     if ( end != NOT_FOUND ) 
  778.     {
  779.         //scan year
  780.         fValue[CentYear] = negate * parseInt(fStart, end);
  781.         fStart = end+1;
  782.         designator = true;
  783.     }
  785.     end = indexOf(fStart, endDate, DURATION_M);
  786.     if ( end != NOT_FOUND ) 
  787.     {
  788.         //scan month
  789.         fValue[Month] = negate * parseInt(fStart, end);
  790.         fStart = end+1;
  791.         designator = true;
  792.     }
  794.     end = indexOf(fStart, endDate, DURATION_D);
  795.     if ( end != NOT_FOUND ) 
  796.     {
  797.         //scan day
  798.         fValue[Day] = negate * parseInt(fStart,end);
  799.         fStart = end+1;
  800.         designator = true;
  801.     }
  803.     if ( (fEnd == endDate) &&   // 'T' absent
  804.          (fStart != fEnd)   )   // something after Day
  805.     {
  806.         ThrowXML1(SchemaDateTimeException
  807.                 , XMLExcepts::DateTime_dur_inv_b4T
  808.                 , fBuffer);
  809.     }
  811.     if ( fEnd != endDate ) // 'T' present
  812.     {
  813.         //scan hours, minutes, seconds
  814.         //         
  816.         // skip 'T' first
  817.         end = indexOf(++fStart, fEnd, DURATION_H);
  818.         if ( end != NOT_FOUND ) 
  819.         {
  820.             //scan hours
  821.             fValue[Hour] = negate * parseInt(fStart, end);
  822.             fStart = end+1;
  823.             designator = true;
  824.         }
  826.         end = indexOf(fStart, fEnd, DURATION_M);
  827.         if ( end != NOT_FOUND ) 
  828.         {
  829.             //scan min
  830.             fValue[Minute] = negate * parseInt(fStart, end);
  831.             fStart = end+1;
  832.             designator = true;
  833.         }
  835.         end = indexOf(fStart, fEnd, DURATION_S);
  836.         if ( end != NOT_FOUND ) 
  837.         {
  838.             //scan seconds
  839.             int mlsec = indexOf (fStart, end, MILISECOND_SEPARATOR);
  840.             if ( mlsec != NOT_FOUND ) 
  841.             {
  842.                 fValue[Second]     = negate * parseInt(fStart, mlsec);
  843.                 fValue[MiliSecond] = negate * parseInt(mlsec+1, end);
  844.             }
  845.             else 
  846.             {
  847.                 fValue[Second] = negate * parseInt(fStart,end);
  848.             }
  849.    
  850.             fStart = end+1;
  851.             designator = true;
  852.         }
  854.         // no additional data should appear after last item
  855.         // P1Y1M1DT is illigal value as well
  856.         if ( (fStart != fEnd) || 
  857.               fBuffer[--fStart] == DATETIME_SEPARATOR ) 
  858.         {
  859.             ThrowXML1(SchemaDateTimeException
  860.                     , XMLExcepts::DateTime_dur_NoTimeAfterT
  861.                     ,fBuffer);
  862.         }
  863.     }
  865.     if ( !designator ) 
  866.     {
  867.         ThrowXML1(SchemaDateTimeException
  868.                 , XMLExcepts::DateTime_dur_NoElementAtAll
  869.                 , fBuffer);
  870.     }
  872. }
  874. // ---------------------------------------------------------------------------
  875. //  Scanners
  876. // ---------------------------------------------------------------------------
  878. //
  879. // [-]{CCYY-MM-DD}
  880. //
  881. // Note: CCYY could be more than 4 digits
  882. //       Assuming fStart point to the beginning of the Date Section
  883. //       fStart updated to point to the position right AFTER the second 'D'
  884. //       Since the lenght of CCYY might be variable, we can't check format upfront
  885. //
  886. void XMLDateTime::getDate()
  887. {
  889.     // Ensure enough chars in buffer
  890.     if ( (fStart+YMD_MIN_SIZE) > fEnd)
  891.         ThrowXML1(SchemaDateTimeException
  892.                 , XMLExcepts::DateTime_date_incomplete
  893.                 , fBuffer);
  895.     getYearMonth();    // Scan YearMonth and 
  896.                        // fStart point to the next '-' 
  898.     if (fBuffer[fStart++] != DATE_SEPARATOR) 
  899.     {
  900.         ThrowXML1(SchemaDateTimeException
  901.                 , XMLExcepts::DateTime_date_invalid
  902.                 , fBuffer);
  903.         //("CCYY-MM must be followed by '-' sign");
  904.     }
  906.     fValue[Day] = parseInt(fStart, fStart+2);
  907.     fStart += 2 ;  //fStart points right after the Day
  909.     return;
  910. }
  912. //
  913. // hh:mm:ss[.msssss]['Z']
  914. // hh:mm:ss[.msssss][['+'|'-']hh:mm]
  915. // 012345678
  916. //
  917. // Note: Assuming fStart point to the beginning of the Time Section
  918. //       fStart updated to point to the position right AFTER the second 's'
  919. //                                                  or ms if any
  920. //
  921. void XMLDateTime::getTime()
  922. {
  924.     // Ensure enough chars in buffer
  925.     if ( (fStart+TIME_MIN_SIZE) > fEnd)
  926.         ThrowXML1(SchemaDateTimeException
  927.                 , XMLExcepts::DateTime_time_incomplete
  928.                 , fBuffer);
  929.         //"Imcomplete Time Format"
  931.     // check (fixed) format first
  932.     if ((fBuffer[fStart + 2] != TIME_SEPARATOR) ||
  933.         (fBuffer[fStart + 5] != TIME_SEPARATOR)  )
  934.     {
  935.         ThrowXML1(SchemaDateTimeException
  936.                 , XMLExcepts::DateTime_time_invalid
  937.                 , fBuffer);
  938.         //("Error in parsing time" );
  939.     }
  941.     //
  942.     // get hours, minute and second
  943.     //
  944.     fValue[Hour]   = parseInt(fStart + 0, fStart + 2);
  945.     fValue[Minute] = parseInt(fStart + 3, fStart + 5);            
  946.     fValue[Second] = parseInt(fStart + 6, fStart + 8);
  947.     fStart += 8;
  949.     // to see if any ms and/or utc part after that
  950.     if (fStart >= fEnd)
  951.         return;
  953.     //find UTC sign if any
  954.     int sign = findUTCSign(fStart);
  956.     //parse miliseconds 
  957.     int milisec = (fBuffer[fStart] == MILISECOND_SEPARATOR)? fStart : NOT_FOUND;
  958.     if ( milisec != NOT_FOUND )
  959.     {
  960.         fStart++;   // skip the '.'
  961.         // make sure we have some thing between the '.' and fEnd
  962.         if (fStart >= fEnd)
  963.         {
  964.             ThrowXML1(SchemaDateTimeException
  965.                     , XMLExcepts::DateTime_ms_noDigit
  966.                     , fBuffer);
  967.             //("ms shall be present once '.' is present" );
  968.         }
  970.         if ( sign == NOT_FOUND ) 
  971.         {
  972.             fValue[MiliSecond] = parseInt(fStart, fEnd);  //get ms between '.' and fEnd
  973.             fStart = fEnd;
  974.         }
  975.         else 
  976.         {
  977.             fValue[MiliSecond] = parseInt(fStart, sign);  //get ms between UTC sign and fEnd
  978.         }
  979. }
  981.     //parse UTC time zone (hh:mm)        
  982.     if ( sign > 0 ) {
  983.         getTimeZone(sign);
  984.     }
  986. }
  988. //
  989. // [-]{CCYY-MM}
  990. //
  991. // Note: CCYY could be more than 4 digits
  992. //       fStart updated to point AFTER the second 'M' (probably meet the fEnd)
  993. //
  994. void XMLDateTime::getYearMonth()
  995. {
  997.     // Ensure enough chars in buffer
  998.     if ( (fStart+YMONTH_MIN_SIZE) > fEnd)
  999.         ThrowXML1(SchemaDateTimeException
  1000.                 , XMLExcepts::DateTime_ym_incomplete
  1001.                 , fBuffer);
  1002.         //"Imcomplete YearMonth Format";
  1004.     // skip the first leading '-'
  1005.     int start = ( fBuffer[0] == chDash ) ? fStart + 1 : fStart;
  1007.     //
  1008.     // search for year separator '-'
  1009.     //
  1010.     int yearSeparator = indexOf(start, fEnd, DATE_SEPARATOR);
  1011.     if ( yearSeparator == NOT_FOUND) 
  1012.         ThrowXML1(SchemaDateTimeException
  1013.                 , XMLExcepts::DateTime_ym_invalid
  1014.                 , fBuffer);
  1015.         //("Year separator is missing or misplaced");
  1017.     fValue[CentYear] = parseIntYear(yearSeparator);
  1018.     fStart = yearSeparator + 1;  //skip the '-' and point to the first M
  1020.     //
  1021.     //gonna check we have enough byte for month
  1022.     //
  1023.     if ((fStart + 2) > fEnd )
  1024.         ThrowXML1(SchemaDateTimeException
  1025.                 , XMLExcepts::DateTime_ym_noMonth
  1026.                 , fBuffer);
  1027.         //"no month in buffer"
  1029.     fValue[Month] = parseInt(fStart, yearSeparator + 3);
  1030.     fStart += 2;  //fStart points right after the MONTH
  1032.     return;
  1033. }
  1035. void XMLDateTime::parseTimeZone()
  1036. {
  1037.     if ( fStart < fEnd ) 
  1038.     {
  1039.         int sign = findUTCSign(fStart);
  1040.         if ( sign < 0 ) 
  1041.         {
  1042.             ThrowXML1(SchemaDateTimeException
  1043.                     , XMLExcepts::DateTime_tz_noUTCsign
  1044.                     , fBuffer);
  1045.             //("Error in month parsing");
  1046.         }
  1047.         else 
  1048.         {
  1049.             getTimeZone(sign);
  1050.         }
  1051.     }
  1053.     return;
  1054. }
  1056. //
  1057. // 'Z'
  1058. // ['+'|'-']hh:mm
  1059. //
  1060. // Note: Assuming fStart points to the beginning of TimeZone section
  1061. //       fStart updated to meet fEnd
  1062. //
  1063. void XMLDateTime::getTimeZone(const int sign)
  1064. {
  1066.     if ( fBuffer[sign] == UTC_STD_CHAR )
  1067.     {
  1068.         if ((sign + 1) != fEnd )
  1069.         {
  1070.             ThrowXML1(SchemaDateTimeException
  1071.                     , XMLExcepts::DateTime_tz_stuffAfterZ
  1072.                     , fBuffer);
  1073.             //"Error in parsing time zone");
  1074.         }
  1076.         return;
  1077.     }
  1079.     //
  1080.     // otherwise, it has to be this format
  1081.     // '[+|-]'hh:mm
  1082.     //    1   23456 7
  1083.     //   sign      fEnd
  1084.     //
  1085.     if ( ( ( sign + TIMEZONE_SIZE + 1) != fEnd )      ||
  1086.          ( fBuffer[sign + 3] != TIMEZONE_SEPARATOR ) )
  1087.     {
  1088.         ThrowXML1(SchemaDateTimeException
  1089.                 , XMLExcepts::DateTime_tz_invalid
  1090.                 , fBuffer);
  1091.         //("Error in parsing time zone");
  1092.     }
  1094.     fTimeZone[hh] = parseInt(sign+1, sign+3);
  1095.     fTimeZone[mm] = parseInt(sign+4, fEnd);
  1096.         
  1097.     return;
  1098. }
  1100. // ---------------------------------------------------------------------------
  1101. //  Validator and normalizer
  1102. // ---------------------------------------------------------------------------
  1104. /**
  1105.  * If timezone present - normalize dateTime  [E Adding durations to dateTimes]
  1106.  * 
  1107.  * @param date   CCYY-MM-DDThh:mm:ss+03
  1108.  * @return CCYY-MM-DDThh:mm:ssZ
  1109.  */
  1110. void XMLDateTime::normalize()
  1111. {  
  1113.     if ((fValue[utc] == UTC_UNKNOWN) ||
  1114.         (fValue[utc] == UTC_STD)      )
  1115.         return;
  1117.     int negate = (fValue[utc] == UTC_POS)? -1: 1;
  1119.     // add mins
  1120.     int temp = fValue[Minute] + negate * fTimeZone[mm];
  1121.     int carry = fQuotient(temp, 60);
  1122.     fValue[Minute] = mod(temp, 60, carry);
  1123.        
  1124.     //add hours
  1125.     temp = fValue[Hour] + negate * fTimeZone[hh] + carry;
  1126.     carry = fQuotient(temp, 24);
  1127.     fValue[Hour] = mod(temp, 24, carry);
  1129.     fValue[Day] += carry;
  1131.     while (1)
  1132.     {
  1133.         temp = maxDayInMonthFor(fValue[CentYear], fValue[Month]);
  1134.         if (fValue[Day] < 1) 
  1135.         {
  1136.             fValue[Day] += maxDayInMonthFor(fValue[CentYear], fValue[Month] - 1);
  1137.             carry = -1;
  1138.         }
  1139.         else if ( fValue[Day] > temp ) 
  1140.         {
  1141.             fValue[Day] -= temp;
  1142.             carry = 1;
  1143.         }
  1144.         else 
  1145.         {
  1146.             break;
  1147.         }
  1149.         temp = fValue[Month] + carry;
  1150.         fValue[Month] = modulo(temp, 1, 13);
  1151.         fValue[CentYear] += fQuotient(temp, 1, 13);
  1152.     }
  1154.     // set to normalized
  1155.     fValue[utc] = UTC_STD;
  1157.     return;
  1158. }
  1160. void XMLDateTime::validateDateTime() const
  1161. {
  1163.     //REVISIT: should we throw an exception for not valid dates
  1164.     //          or reporting an error message should be sufficient?  
  1165.     if ( fValue[CentYear] == 0 ) 
  1166.     {
  1167.         ThrowXML1(SchemaDateTimeException
  1168.                 , XMLExcepts::DateTime_year_zero
  1169.                 , fBuffer);
  1170.         //"The year "0000" is an illegal year value");
  1171.     }
  1173.     if ( fValue[Month] < 1  || 
  1174.          fValue[Month] > 12  ) 
  1175.     {
  1176.         ThrowXML1(SchemaDateTimeException
  1177.                 , XMLExcepts::DateTime_mth_invalid
  1178.                 , fBuffer);
  1179. //"The month must have values 1 to 12");
  1180.     }
  1182.     //validate days
  1183.     if ( fValue[Day] > maxDayInMonthFor( fValue[CentYear], fValue[Month]) ||
  1184.          fValue[Day] == 0 ) 
  1185.     {
  1186.         ThrowXML1(SchemaDateTimeException
  1187.                 , XMLExcepts::DateTime_day_invalid
  1188.                 , fBuffer);
  1189.         //"The day must have values 1 to 31");
  1190.     }
  1192.     //validate hours
  1193.     if ((fValue[Hour] < 0)  || 
  1194.         (fValue[Hour] > 23) || 
  1195.         ((fValue[Hour] == 24) && ((fValue[Minute] !=0) || 
  1196.                                   (fValue[Second] !=0) ||
  1197.                                   (fValue[MiliSecond] !=0)))) 
  1198.     {
  1199.         ThrowXML1(SchemaDateTimeException
  1200.                 , XMLExcepts::DateTime_hour_invalid
  1201.                 , fBuffer);
  1202.         //("Hour must have values 0-23");
  1203.     }
  1205.     //validate minutes
  1206.     if ( fValue[Minute] < 0 ||
  1207.          fValue[Minute] > 59 )
  1208.     {
  1209.         ThrowXML1(SchemaDateTimeException
  1210.                 , XMLExcepts::DateTime_min_invalid
  1211.                 , fBuffer);
  1212.         //"Minute must have values 0-59");
  1213.     }
  1215.     //validate seconds
  1216.     if ( fValue[Second] < 0 ||
  1217.          fValue[Second] > 60 )
  1218.     {
  1219.         ThrowXML1(SchemaDateTimeException
  1220.                 , XMLExcepts::DateTime_second_invalid
  1221.                 , fBuffer);
  1222.         //"Second must have values 0-60");
  1223.     }
  1225.     //validate time-zone hours
  1226.     if ( (abs(fTimeZone[hh]) > 14) ||
  1227.          ((abs(fTimeZone[hh]) == 14) && (fTimeZone[mm] != 0)) )
  1228.     {
  1229.         ThrowXML1(SchemaDateTimeException
  1230.                 , XMLExcepts::DateTime_tz_hh_invalid
  1231.                 , fBuffer);
  1232.         //"Time zone should have range -14..+14");
  1233.     }
  1235.     //validate time-zone minutes
  1236.     if ( abs(fTimeZone[mm]) > 59 )
  1237.     {
  1238.         ThrowXML1(SchemaDateTimeException
  1239.                 , XMLExcepts::DateTime_min_invalid
  1240.                 , fBuffer);
  1241.         //("Minute must have values 0-59");
  1242.     }
  1244.     return;
  1245. }
  1247. // -----------------------------------------------------------------------
  1248. // locator and converter
  1249. // -----------------------------------------------------------------------
  1250. int XMLDateTime::indexOf(const int start, const int end, const XMLCh ch) const
  1251. {
  1252.     for ( int i = start; i < end; i++ ) 
  1253.         if ( fBuffer[i] == ch ) 
  1254.             return i;
  1256.     return NOT_FOUND;
  1257. }
  1259. int XMLDateTime::findUTCSign (const int start)
  1260. {
  1261.     int  pos;
  1262.     for ( int index = start; index < fEnd; index++ ) 
  1263.     {
  1264.         pos = XMLString::indexOf(UTC_SET, fBuffer[index]);
  1265.         if ( pos != NOT_FOUND)
  1266.         {
  1267.             fValue[utc] = pos+1;   // refer to utcType, there is 1 diff
  1268.             return index;
  1269.         }
  1270.     }
  1272.     return NOT_FOUND;
  1273. }
  1275. //
  1276. // Note:
  1277. //    start: starting point in fBuffer
  1278. //    end:   ending point in fBuffer (exclusive)
  1279. //    fStart NOT updated
  1280. //
  1281. int XMLDateTime::parseInt(const int start, const int end) const
  1282. {
  1284.     XMLCh* strToScan = new XMLCh[end - start + 1];
  1285.     ArrayJanitor<XMLCh>  jname(strToScan);
  1286.     XMLString::subString(strToScan, fBuffer, start, end);
  1288.     unsigned int retVal;
  1289.     XMLString::textToBin(strToScan, retVal);
  1291.     return (int) retVal;
  1292. }
  1294. //
  1295. // [-]CCYY
  1296. // 
  1297. // Note: start from fStart
  1298. //       end (exclusive)
  1299. //       fStart NOT updated
  1300. //
  1301. int XMLDateTime::parseIntYear(const int end) const
  1302. {
  1303.     // skip the first leading '-'
  1304.     int start = ( fBuffer[0] == chDash ) ? fStart + 1 : fStart;
  1306.     int length = end - start;
  1307.     if (length < 4) 
  1308.     {
  1309.         ThrowXML1(SchemaDateTimeException
  1310.                 , XMLExcepts::DateTime_year_tooShort
  1311.                 , fBuffer);
  1312.         //"Year must have 'CCYY' format");
  1313.     }
  1314.     else if (length > 4 && 
  1315.              fBuffer[start] == chDigit_0)
  1316.     {
  1317.         ThrowXML1(SchemaDateTimeException
  1318.                 , XMLExcepts::DateTime_year_leadingZero
  1319.                 , fBuffer);
  1320.         //"Leading zeros are required if the year value would otherwise have fewer than four digits; 
  1321.         // otherwise they are forbidden");
  1322.     }
  1324.     bool negative = (fBuffer[0] == chDash);
  1325.     int  yearVal = parseInt((negative ? 1 : 0), end);
  1326.     return ( negative ? (-1) * yearVal : yearVal );
  1327. }