00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022 #if !defined(XERCESC_INCLUDE_GUARD_XML_DATETIME_HPP)
00023 #define XERCESC_INCLUDE_GUARD_XML_DATETIME_HPP
00024
00025 #include <xercesc/util/XMLNumber.hpp>
00026 #include <xercesc/util/PlatformUtils.hpp>
00027 #include <xercesc/util/XMLString.hpp>
00028 #include <xercesc/util/XMLUniDefs.hpp>
00029 #include <xercesc/util/SchemaDateTimeException.hpp>
00030 #include <xercesc/util/XMLChar.hpp>
00031
00032 XERCES_CPP_NAMESPACE_BEGIN
00033
00034 class XSValue;
00035
00036 class XMLUTIL_EXPORT XMLDateTime : public XMLNumber
00037 {
00038 public:
00039
00040 enum valueIndex
00041 {
00042 CentYear = 0,
00043 Month ,
00044 Day ,
00045 Hour ,
00046 Minute ,
00047 Second ,
00048 MiliSecond ,
00049 utc ,
00050 TOTAL_SIZE
00051 };
00052
00053 enum utcType
00054 {
00055 UTC_UNKNOWN = 0,
00056 UTC_STD ,
00057 UTC_POS ,
00058 UTC_NEG
00059 };
00060
00061
00062
00063
00064
00065 XMLDateTime(MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
00066 XMLDateTime(const XMLCh* const,
00067 MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
00068 ~XMLDateTime();
00069
00070 inline void setBuffer(const XMLCh* const);
00071
00072
00073
00074
00075
00076 XMLDateTime(const XMLDateTime&);
00077
00078 XMLDateTime& operator=(const XMLDateTime&);
00079
00080
00081
00082
00083
00084 virtual XMLCh* getRawData() const;
00085
00086 virtual const XMLCh* getFormattedString() const;
00087
00088 virtual int getSign() const;
00089
00090
00091
00092
00093
00094 XMLCh* getDateTimeCanonicalRepresentation(MemoryManager* const memMgr) const;
00095
00096 XMLCh* getTimeCanonicalRepresentation(MemoryManager* const memMgr) const;
00097
00098 XMLCh* getDateCanonicalRepresentation(MemoryManager* const memMgr) const;
00099
00100
00101
00102
00103
00104 void parseDateTime();
00105
00106 void parseDate();
00107
00108 void parseTime();
00109
00110 void parseDay();
00111
00112 void parseMonth();
00113
00114 void parseYear();
00115
00116 void parseMonthDay();
00117
00118 void parseYearMonth();
00119
00120 void parseDuration();
00121
00122
00123
00124
00125 static int compare(const XMLDateTime* const
00126 , const XMLDateTime* const);
00127
00128 static int compare(const XMLDateTime* const
00129 , const XMLDateTime* const
00130 , bool );
00131
00132 static int compareOrder(const XMLDateTime* const
00133 , const XMLDateTime* const);
00134
00135
00136
00137
00138 DECL_XSERIALIZABLE(XMLDateTime)
00139
00140 private:
00141
00142
00143
00144
00145
00146
00147 enum timezoneIndex
00148 {
00149 hh = 0,
00150 mm ,
00151 TIMEZONE_ARRAYSIZE
00152 };
00153
00154
00155
00156
00157 static int compareResult(int
00158 , int
00159 , bool);
00160
00161 static void addDuration(XMLDateTime* pDuration
00162 , const XMLDateTime* const pBaseDate
00163 , int index);
00164
00165
00166 static int compareResult(const XMLDateTime* const
00167 , const XMLDateTime* const
00168 , bool
00169 , int);
00170
00171 static inline int getRetVal(int, int);
00172
00173
00174
00175
00176
00177 inline void reset();
00178
00179 inline void assertBuffer() const;
00180
00181 inline void copy(const XMLDateTime&);
00182
00183
00184 inline bool initParser();
00185
00186 inline bool isNormalized() const;
00187
00188
00189
00190
00191
00192 void getDate();
00193
00194 void getTime();
00195
00196 void getYearMonth();
00197
00198 void getTimeZone(const XMLSize_t);
00199
00200 void parseTimeZone();
00201
00202
00203
00204
00205
00206 int findUTCSign(const XMLSize_t start);
00207
00208 int indexOf(const XMLSize_t start
00209 , const XMLSize_t end
00210 , const XMLCh ch) const;
00211
00212 int parseInt(const XMLSize_t start
00213 , const XMLSize_t end) const;
00214
00215 int parseIntYear(const XMLSize_t end) const;
00216
00217 double parseMiliSecond(const XMLSize_t start
00218 , const XMLSize_t end) const;
00219
00220
00221
00222
00223
00224 void validateDateTime() const;
00225
00226 void normalize();
00227
00228 void fillString(XMLCh*& ptr, int value, XMLSize_t expLen) const;
00229
00230 int fillYearString(XMLCh*& ptr, int value) const;
00231
00232 void searchMiliSeconds(XMLCh*& miliStartPtr, XMLCh*& miliEndPtr) const;
00233
00234
00235
00236
00237 bool operator==(const XMLDateTime& toCompare) const;
00238
00239
00240
00241
00242
00243
00244
00245
00246
00247
00248
00249
00250
00251
00252
00253
00254
00255
00256
00257 int fValue[TOTAL_SIZE];
00258 int fTimeZone[TIMEZONE_ARRAYSIZE];
00259 XMLSize_t fStart;
00260 XMLSize_t fEnd;
00261 XMLSize_t fBufferMaxLen;
00262
00263 double fMilliSecond;
00264 bool fHasTime;
00265
00266 XMLCh* fBuffer;
00267 MemoryManager* fMemoryManager;
00268
00269 friend class XSValue;
00270 };
00271
00272 inline void XMLDateTime::setBuffer(const XMLCh* const aString)
00273 {
00274 reset();
00275
00276 fEnd = XMLString::stringLen(aString);
00277
00278 for (; fEnd > 0; fEnd--)
00279 {
00280 if (!XMLChar1_0::isWhitespace(aString[fEnd - 1]))
00281 break;
00282 }
00283
00284 if (fEnd > 0) {
00285
00286 if (fEnd > fBufferMaxLen)
00287 {
00288 fMemoryManager->deallocate(fBuffer);
00289 fBufferMaxLen = fEnd + 8;
00290 fBuffer = (XMLCh*) fMemoryManager->allocate((fBufferMaxLen+1) * sizeof(XMLCh));
00291 }
00292
00293 memcpy(fBuffer, aString, (fEnd) * sizeof(XMLCh));
00294 fBuffer[fEnd] = '\0';
00295 }
00296 }
00297
00298 inline void XMLDateTime::reset()
00299 {
00300 for ( int i=0; i < TOTAL_SIZE; i++ )
00301 fValue[i] = 0;
00302
00303 fMilliSecond = 0;
00304 fHasTime = false;
00305 fTimeZone[hh] = fTimeZone[mm] = 0;
00306 fStart = fEnd = 0;
00307
00308 if (fBuffer)
00309 *fBuffer = 0;
00310 }
00311
00312 inline void XMLDateTime::copy(const XMLDateTime& rhs)
00313 {
00314 for ( int i = 0; i < TOTAL_SIZE; i++ )
00315 fValue[i] = rhs.fValue[i];
00316
00317 fMilliSecond = rhs.fMilliSecond;
00318 fHasTime = rhs.fHasTime;
00319 fTimeZone[hh] = rhs.fTimeZone[hh];
00320 fTimeZone[mm] = rhs.fTimeZone[mm];
00321 fStart = rhs.fStart;
00322 fEnd = rhs.fEnd;
00323
00324 if (fEnd > 0)
00325 {
00326 if (fEnd > fBufferMaxLen)
00327 {
00328 fMemoryManager->deallocate(fBuffer);
00329 fBufferMaxLen = rhs.fBufferMaxLen;
00330 fBuffer = (XMLCh*) fMemoryManager->allocate((fBufferMaxLen+1) * sizeof(XMLCh));
00331 }
00332
00333 memcpy(fBuffer, rhs.fBuffer, (fEnd+1) * sizeof(XMLCh));
00334 }
00335 }
00336
00337 inline bool XMLDateTime::initParser()
00338 {
00339 if (!fBuffer || fBuffer[0] == chNull)
00340 return false;
00341
00342 fStart = 0;
00343
00344
00345 return true;
00346 }
00347
00348 inline bool XMLDateTime::isNormalized() const
00349 {
00350 return ( fValue[utc] == UTC_STD ? true : false );
00351 }
00352
00353 inline int XMLDateTime::getRetVal(int c1, int c2)
00354 {
00355 if ((c1 == LESS_THAN && c2 == GREATER_THAN) ||
00356 (c1 == GREATER_THAN && c2 == LESS_THAN) )
00357 {
00358 return INDETERMINATE;
00359 }
00360
00361 return ( c1 != INDETERMINATE ) ? c1 : c2;
00362 }
00363
00364 XERCES_CPP_NAMESPACE_END
00365
00366 #endif