XMLDateTime.hpp Source File

00001 /*
00002  * Copyright 2001,2004 The Apache Software Foundation.
00003  * 
00004  * Licensed under the Apache License, Version 2.0 (the "License");
00005  * you may not use this file except in compliance with the License.
00006  * You may obtain a copy of the License at
00007  * 
00008  *      http://www.apache.org/licenses/LICENSE-2.0
00009  * 
00010  * Unless required by applicable law or agreed to in writing, software
00011  * distributed under the License is distributed on an "AS IS" BASIS,
00012  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00013  * See the License for the specific language governing permissions and
00014  * limitations under the License.
00015  */
00016 
00017 /*
00018  * $Id: XMLDateTime.hpp,v 1.20 2004/09/08 13:56:24 peiyongz Exp $
00019  * $Log: XMLDateTime.hpp,v $
00020  * Revision 1.20  2004/09/08 13:56:24  peiyongz
00021  * Apache License Version 2.0
00022  *
00023  * Revision 1.19  2004/08/31 20:50:50  peiyongz
00024  * Parse/keep milisecond as double to retain precision.
00025  *
00026  * Revision 1.18  2004/08/11 16:48:55  peiyongz
00027  * Allow XSValue access
00028  *
00029  * Revision 1.17  2004/01/29 11:48:47  cargilld
00030  * Code cleanup changes to get rid of various compiler diagnostic messages.
00031  *
00032  * Revision 1.16  2004/01/13 19:50:56  peiyongz
00033  * remove parseContent()
00034  *
00035  * Revision 1.14  2003/12/31 02:34:11  neilg
00036  * enable production of canonical representations for dates with negative years, or years >9999
00037  *
00038  * Revision 1.13  2003/12/17 20:00:49  cargilld
00039  * Update for memory management so that the static memory manager (one
00040  * used to call Initialize) is only for static data.
00041  *
00042  * Revision 1.12  2003/12/17 00:18:35  cargilld
00043  * Update to memory management so that the static memory manager (one used to call Initialize) is only for static data.
00044  *
00045  * Revision 1.11  2003/12/11 21:38:12  peiyongz
00046  * support for Canonical Representation for Datatype
00047  *
00048  * Revision 1.10  2003/09/23 18:16:07  peiyongz
00049  * Inplementation for Serialization/Deserialization
00050  *
00051  * Revision 1.9  2003/08/14 02:57:27  knoaman
00052  * Code refactoring to improve performance of validation.
00053  *
00054  * Revision 1.8  2003/05/18 14:02:05  knoaman
00055  * Memory manager implementation: pass per instance manager.
00056  *
00057  * Revision 1.7  2003/05/15 19:07:46  knoaman
00058  * Partial implementation of the configurable memory manager.
00059  *
00060  * Revision 1.6  2003/05/09 15:13:46  peiyongz
00061  * Deprecated toString() in XMLNumber family
00062  *
00063  * Revision 1.5  2003/03/10 20:55:58  peiyongz
00064  * Schema Errata E2-40 double/float
00065  *
00066  * Revision 1.4  2003/02/02 23:54:43  peiyongz
00067  * getFormattedString() added to return original and converted value.
00068  *
00069  * Revision 1.3  2003/01/30 21:55:22  tng
00070  * Performance: create getRawData which is similar to toString but return the internal data directly, user is not required to delete the returned memory.
00071  *
00072  * Revision 1.2  2002/11/04 15:22:05  tng
00073  * C++ Namespace Support.
00074  *
00075  * Revision 1.1.1.1  2002/02/01 22:22:14  peiyongz
00076  * sane_include
00077  *
00078  * Revision 1.4  2001/11/22 20:23:00  peiyongz
00079  * _declspec(dllimport) and inline warning C4273
00080  *
00081  * Revision 1.3  2001/11/12 20:36:54  peiyongz
00082  * SchemaDateTimeException defined
00083  *
00084  * Revision 1.2  2001/11/09 20:41:45  peiyongz
00085  * Fix: compilation error on Solaris and AIX.
00086  *
00087  * Revision 1.1  2001/11/07 19:16:03  peiyongz
00088  * DateTime Port
00089  *
00090  */
00091 
00092 #ifndef XML_DATETIME_HPP
00093 #define XML_DATETIME_HPP
00094 
00095 #include <xercesc/util/XMLNumber.hpp>
00096 #include <xercesc/util/PlatformUtils.hpp>
00097 #include <xercesc/util/XMLString.hpp>
00098 #include <xercesc/util/XMLUniDefs.hpp>
00099 #include <xercesc/util/SchemaDateTimeException.hpp>
00100 
00101 XERCES_CPP_NAMESPACE_BEGIN
00102 
00103 class XSValue;
00104 
00105 class  XMLDateTime : public XMLNumber
00106 {
00107 public:
00108 
00109     enum valueIndex
00110     {
00111         CentYear   = 0,
00112         Month      ,
00113         Day        ,
00114         Hour       ,
00115         Minute     ,
00116         Second     ,
00117         MiliSecond ,  //not to be used directly
00118         utc        ,
00119         TOTAL_SIZE
00120     };
00121 
00122     enum utcType
00123     {
00124         UTC_UNKNOWN = 0,
00125         UTC_STD        ,          // set in parse() or normalize()
00126         UTC_POS        ,          // set in parse()
00127         UTC_NEG                   // set in parse()
00128     };
00129 
00130     // -----------------------------------------------------------------------
00131     // ctors and dtor
00132     // -----------------------------------------------------------------------
00133 
00134     XMLDateTime(MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
00135     XMLDateTime(const XMLCh* const,
00136                 MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
00137     ~XMLDateTime();
00138 
00139     inline void           setBuffer(const XMLCh* const);
00140 
00141     // -----------------------------------------------------------------------
00142     // Copy ctor and Assignment operators
00143     // -----------------------------------------------------------------------
00144 
00145     XMLDateTime(const XMLDateTime&);
00146 
00147     XMLDateTime&          operator=(const XMLDateTime&);
00148 
00149     // -----------------------------------------------------------------------
00150     // Implementation of Abstract Interface
00151     // -----------------------------------------------------------------------
00152 
00158     virtual XMLCh*        toString() const;
00159     
00160     virtual XMLCh*        getRawData() const;
00161 
00162     virtual const XMLCh*  getFormattedString() const;
00163 
00164     virtual int           getSign() const;
00165 
00166     // -----------------------------------------------------------------------
00167     // Canonical Representation
00168     // -----------------------------------------------------------------------
00169 
00170     XMLCh*                getDateTimeCanonicalRepresentation(MemoryManager* const memMgr) const;
00171 
00172     XMLCh*                getTimeCanonicalRepresentation(MemoryManager* const memMgr)     const;
00173 
00174     // -----------------------------------------------------------------------
00175     // parsers
00176     // -----------------------------------------------------------------------
00177 
00178     void                  parseDateTime();       //DateTime
00179 
00180     void                  parseDate();           //Date
00181 
00182     void                  parseTime();           //Time
00183 
00184     void                  parseDay();            //gDay
00185 
00186     void                  parseMonth();          //gMonth
00187 
00188     void                  parseYear();           //gYear
00189 
00190     void                  parseMonthDay();       //gMonthDay
00191 
00192     void                  parseYearMonth();      //gYearMonth
00193 
00194     void                  parseDuration();       //duration
00195 
00196     // -----------------------------------------------------------------------
00197     // Comparison
00198     // -----------------------------------------------------------------------
00199     static int            compare(const XMLDateTime* const
00200                                 , const XMLDateTime* const);
00201 
00202     static int            compare(const XMLDateTime* const
00203                                 , const XMLDateTime* const
00204                                 , bool                    );
00205 
00206     static int            compareOrder(const XMLDateTime* const
00207                                      , const XMLDateTime* const);                                    
00208 
00209     /***
00210      * Support for Serialization/De-serialization
00211      ***/
00212     DECL_XSERIALIZABLE(XMLDateTime)
00213 
00214 private:
00215 
00216     // -----------------------------------------------------------------------
00217     // Constant data
00218     // -----------------------------------------------------------------------
00219     //
00220 
00221     enum timezoneIndex
00222     {
00223         hh = 0,
00224         mm ,
00225         TIMEZONE_ARRAYSIZE
00226     };
00227 
00228     // -----------------------------------------------------------------------
00229     // Comparison
00230     // -----------------------------------------------------------------------
00231     static int            compareResult(int
00232                                       , int
00233                                       , bool);
00234 
00235     static void           addDuration(XMLDateTime*             pDuration
00236                                     , const XMLDateTime* const pBaseDate
00237                                     , int                      index);
00238 
00239 
00240     static int            compareResult(const XMLDateTime* const
00241                                       , const XMLDateTime* const
00242                                       , bool
00243                                       , int);
00244 
00245     static inline int     getRetVal(int, int);
00246 
00247     // -----------------------------------------------------------------------
00248     // helper
00249     // -----------------------------------------------------------------------
00250 
00251     inline  void          reset();
00252 
00253     inline  void          assertBuffer()               const;
00254 
00255     inline  void          copy(const XMLDateTime&);
00256 
00257     // allow multiple parsing
00258     inline  void          initParser();
00259 
00260     inline  bool          isNormalized()               const;
00261 
00262     // -----------------------------------------------------------------------
00263     // scaners
00264     // -----------------------------------------------------------------------
00265 
00266     void                  getDate();
00267 
00268     void                  getTime();
00269 
00270     void                  getYearMonth();
00271 
00272     void                  getTimeZone(const int);
00273 
00274     void                  parseTimeZone();
00275 
00276     // -----------------------------------------------------------------------
00277     // locator and converter
00278     // -----------------------------------------------------------------------
00279 
00280     int                   findUTCSign(const int start);
00281 
00282     int                   indexOf(const int start
00283                                 , const int end
00284                                 , const XMLCh ch)     const;
00285 
00286     int                   parseInt(const int start
00287                                  , const int end)     const;
00288 
00289     int                   parseIntYear(const int end) const;
00290 
00291     double                parseMiliSecond(const int start
00292                                         , const int end) const;
00293 
00294     // -----------------------------------------------------------------------
00295     // validator and normalizer
00296     // -----------------------------------------------------------------------
00297 
00298     void                  validateDateTime()          const;
00299 
00300     void                  normalize();
00301 
00302     void                  fillString(XMLCh*& ptr, valueIndex ind, int expLen) const;
00303 
00304     int                   fillYearString(XMLCh*& ptr, valueIndex ind) const;
00305 
00306     void                  searchMiliSeconds(XMLCh*& miliStartPtr, XMLCh*& miliEndPtr) const;
00307 
00308     // -----------------------------------------------------------------------
00309     // Unimplemented operator ==
00310     // -----------------------------------------------------------------------
00311     bool operator==(const XMLDateTime& toCompare) const;
00312 
00313 
00314     // -----------------------------------------------------------------------
00315     //  Private data members
00316     //
00317     //     fValue[]
00318     //          object representation of date time.
00319     //
00320     //     fTimeZone[]
00321     //          temporary storage for normalization
00322     //
00323     //     fStart, fEnd
00324     //          pointers to the portion of fBuffer being parsed
00325     //
00326     //     fBuffer
00327     //          raw data to be parsed, own it.
00328     //
00329     // -----------------------------------------------------------------------
00330 
00331     int          fValue[TOTAL_SIZE];
00332     int          fTimeZone[TIMEZONE_ARRAYSIZE];
00333     int          fStart;
00334     int          fEnd;
00335     int          fBufferMaxLen;
00336     XMLCh*       fBuffer;
00337 
00338     double       fMiliSecond;
00339     bool         fHasTime;
00340 
00341     MemoryManager* fMemoryManager;
00342 
00343     friend class XSValue;
00344 };
00345 
00346 inline void XMLDateTime::setBuffer(const XMLCh* const aString)
00347 {
00348     reset();
00349 
00350     fEnd = XMLString::stringLen(aString);
00351     if (fEnd > 0) {
00352     
00353         if (fEnd > fBufferMaxLen)
00354         {
00355             fMemoryManager->deallocate(fBuffer);
00356             fBufferMaxLen = fEnd + 8;
00357             fBuffer = (XMLCh*) fMemoryManager->allocate((fBufferMaxLen+1) * sizeof(XMLCh));
00358         }
00359 
00360         memcpy(fBuffer, aString, (fEnd+1) * sizeof(XMLCh));
00361     }
00362 }
00363 
00364 inline void XMLDateTime::reset()
00365 {
00366     for ( int i=0; i < TOTAL_SIZE; i++ )
00367         fValue[i] = 0;
00368 
00369     fMiliSecond   = 0;
00370     fHasTime      = false;
00371     fTimeZone[hh] = fTimeZone[mm] = 0;
00372     fStart = fEnd = 0;
00373 
00374     if (fBuffer)
00375         *fBuffer = 0;
00376 }
00377 
00378 inline void XMLDateTime::copy(const XMLDateTime& rhs)
00379 {
00380     for ( int i = 0; i < TOTAL_SIZE; i++ )
00381         fValue[i] = rhs.fValue[i];
00382 
00383     fMiliSecond   = rhs.fMiliSecond;
00384     fHasTime      = rhs.fHasTime;
00385     fTimeZone[hh] = rhs.fTimeZone[hh];
00386     fTimeZone[mm] = rhs.fTimeZone[mm];
00387     fStart = rhs.fStart;
00388     fEnd   = rhs.fEnd;
00389 
00390     if (fEnd > 0)
00391     {
00392         if (fEnd > fBufferMaxLen)
00393         {
00394             fMemoryManager->deallocate(fBuffer);//delete[] fBuffer;
00395             fBufferMaxLen = rhs.fBufferMaxLen;
00396             fBuffer = (XMLCh*) fMemoryManager->allocate((fBufferMaxLen+1) * sizeof(XMLCh));
00397         }
00398 
00399         memcpy(fBuffer, rhs.fBuffer, (fEnd+1) * sizeof(XMLCh));
00400     }
00401 }
00402 
00403 inline void XMLDateTime::assertBuffer() const
00404 {
00405     if ( ( !fBuffer )            ||
00406          ( fBuffer[0] == chNull ) )
00407     {
00408         ThrowXMLwithMemMgr(SchemaDateTimeException
00409                , XMLExcepts::DateTime_Assert_Buffer_Fail
00410                , fMemoryManager);
00411     }
00412 
00413 }
00414 
00415 inline void XMLDateTime::initParser()
00416 {
00417     assertBuffer();
00418     fStart = 0;   // to ensure scan from the very first beginning
00419                   // in case the pointer is updated accidentally by someone else.
00420 }
00421 
00422 inline bool XMLDateTime::isNormalized() const
00423 {
00424     return ( fValue[utc] == UTC_STD ? true : false );
00425 }
00426 
00427 inline int XMLDateTime::getRetVal(int c1, int c2)
00428 {
00429     if ((c1 == LESS_THAN    && c2 == GREATER_THAN) ||
00430         (c1 == GREATER_THAN && c2 == LESS_THAN)      )
00431     {
00432         return INDETERMINATE;
00433     }
00434 
00435     return ( c1 != INDETERMINATE ) ? c1 : c2;
00436 }
00437 
00438 XERCES_CPP_NAMESPACE_END
00439 
00440 #endif