| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| /* |
| * $Id$ |
| */ |
| |
| #if !defined(XERCESC_INCLUDE_GUARD_XML_DATETIME_HPP) |
| #define XERCESC_INCLUDE_GUARD_XML_DATETIME_HPP |
| |
| #include <xercesc/util/XMLNumber.hpp> |
| #include <xercesc/util/PlatformUtils.hpp> |
| #include <xercesc/util/XMLString.hpp> |
| #include <xercesc/util/XMLUniDefs.hpp> |
| #include <xercesc/util/SchemaDateTimeException.hpp> |
| #include <xercesc/util/XMLChar.hpp> |
| |
| #include <time.h> |
| |
| XERCES_CPP_NAMESPACE_BEGIN |
| |
| class XSValue; |
| |
| class XMLUTIL_EXPORT XMLDateTime : public XMLNumber |
| { |
| public: |
| |
| enum valueIndex |
| { |
| CentYear = 0, |
| Month , |
| Day , |
| Hour , |
| Minute , |
| Second , |
| MiliSecond , //not to be used directly |
| utc , |
| TOTAL_SIZE |
| }; |
| |
| enum utcType |
| { |
| UTC_UNKNOWN = 0, |
| UTC_STD , // set in parse() or normalize() |
| UTC_POS , // set in parse() |
| UTC_NEG // set in parse() |
| }; |
| |
| // ----------------------------------------------------------------------- |
| // ctors and dtor |
| // ----------------------------------------------------------------------- |
| |
| XMLDateTime(MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager); |
| XMLDateTime(const XMLCh* const, |
| MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager); |
| XMLDateTime(time_t epoch, bool duration, |
| MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager); |
| ~XMLDateTime(); |
| |
| inline void setBuffer(const XMLCh* const); |
| |
| // ----------------------------------------------------------------------- |
| // Copy ctor and Assignment operators |
| // ----------------------------------------------------------------------- |
| |
| XMLDateTime(const XMLDateTime&); |
| |
| XMLDateTime& operator=(const XMLDateTime&); |
| |
| // ----------------------------------------------------------------------- |
| // Implementation of Abstract Interface |
| // ----------------------------------------------------------------------- |
| |
| virtual XMLCh* getRawData() const; |
| |
| virtual const XMLCh* getFormattedString() const; |
| |
| virtual int getSign() const; |
| |
| // ----------------------------------------------------------------------- |
| // Canonical Representation |
| // ----------------------------------------------------------------------- |
| |
| XMLCh* getDateTimeCanonicalRepresentation(MemoryManager* const memMgr) const; |
| |
| XMLCh* getTimeCanonicalRepresentation(MemoryManager* const memMgr) const; |
| |
| XMLCh* getDateCanonicalRepresentation(MemoryManager* const memMgr) const; |
| |
| // ----------------------------------------------------------------------- |
| // parsers |
| // ----------------------------------------------------------------------- |
| |
| void parseDateTime(); //DateTime |
| |
| void parseDate(); //Date |
| |
| void parseTime(); //Time |
| |
| void parseDay(); //gDay |
| |
| void parseMonth(); //gMonth |
| |
| void parseYear(); //gYear |
| |
| void parseMonthDay(); //gMonthDay |
| |
| void parseYearMonth(); //gYearMonth |
| |
| void parseDuration(); //duration |
| |
| // ----------------------------------------------------------------------- |
| // Comparison |
| // ----------------------------------------------------------------------- |
| static int compare(const XMLDateTime* const |
| , const XMLDateTime* const); |
| |
| static int compare(const XMLDateTime* const |
| , const XMLDateTime* const |
| , bool ); |
| |
| static int compareOrder(const XMLDateTime* const |
| , const XMLDateTime* const); |
| |
| int getYear() const {return fValue[CentYear];} |
| int getMonth() const {return fValue[Month];} |
| int getDay() const {return fValue[Day];} |
| int getHour() const {return fValue[Hour];} |
| int getMinute() const {return fValue[Minute];} |
| int getSecond() const {return fValue[Second];} |
| time_t getEpoch(bool duration=false) const; |
| |
| /*** |
| * Support for Serialization/De-serialization |
| ***/ |
| DECL_XSERIALIZABLE(XMLDateTime) |
| |
| private: |
| |
| // ----------------------------------------------------------------------- |
| // Constant data |
| // ----------------------------------------------------------------------- |
| // |
| |
| enum timezoneIndex |
| { |
| hh = 0, |
| mm , |
| TIMEZONE_ARRAYSIZE |
| }; |
| |
| // ----------------------------------------------------------------------- |
| // Comparison |
| // ----------------------------------------------------------------------- |
| static int compareResult(int |
| , int |
| , bool); |
| |
| static void addDuration(XMLDateTime* pDuration |
| , const XMLDateTime* const pBaseDate |
| , int index); |
| |
| |
| static int compareResult(const XMLDateTime* const |
| , const XMLDateTime* const |
| , bool |
| , int); |
| |
| static inline int getRetVal(int, int); |
| |
| // ----------------------------------------------------------------------- |
| // helper |
| // ----------------------------------------------------------------------- |
| |
| inline void reset(); |
| |
| inline void assertBuffer() const; |
| |
| inline void copy(const XMLDateTime&); |
| |
| // allow multiple parsing |
| inline bool initParser(); |
| |
| inline bool isNormalized() const; |
| |
| // ----------------------------------------------------------------------- |
| // scaners |
| // ----------------------------------------------------------------------- |
| |
| void getDate(); |
| |
| void getTime(); |
| |
| void getYearMonth(); |
| |
| void getTimeZone(const XMLSize_t); |
| |
| void parseTimeZone(); |
| |
| // ----------------------------------------------------------------------- |
| // locator and converter |
| // ----------------------------------------------------------------------- |
| |
| int findUTCSign(const XMLSize_t start); |
| |
| int indexOf(const XMLSize_t start |
| , const XMLSize_t end |
| , const XMLCh ch) const; |
| |
| int parseInt(const XMLSize_t start |
| , const XMLSize_t end) const; |
| |
| int parseIntYear(const XMLSize_t end) const; |
| |
| double parseMiliSecond(const XMLSize_t start |
| , const XMLSize_t end) const; |
| |
| // ----------------------------------------------------------------------- |
| // validator and normalizer |
| // ----------------------------------------------------------------------- |
| |
| void validateDateTime() const; |
| |
| void normalize(); |
| |
| void fillString(XMLCh*& ptr, int value, XMLSize_t expLen) const; |
| |
| int fillYearString(XMLCh*& ptr, int value) const; |
| |
| void searchMiliSeconds(XMLCh*& miliStartPtr, XMLCh*& miliEndPtr) const; |
| |
| // ----------------------------------------------------------------------- |
| // Unimplemented operator == |
| // ----------------------------------------------------------------------- |
| bool operator==(const XMLDateTime& toCompare) const; |
| |
| |
| // ----------------------------------------------------------------------- |
| // Private data members |
| // |
| // fValue[] |
| // object representation of date time. |
| // |
| // fTimeZone[] |
| // temporary storage for normalization |
| // |
| // fStart, fEnd |
| // pointers to the portion of fBuffer being parsed |
| // |
| // fBuffer |
| // raw data to be parsed, own it. |
| // |
| // ----------------------------------------------------------------------- |
| |
| int fValue[TOTAL_SIZE]; |
| int fTimeZone[TIMEZONE_ARRAYSIZE]; |
| XMLSize_t fStart; |
| XMLSize_t fEnd; |
| XMLSize_t fBufferMaxLen; |
| |
| double fMilliSecond; |
| bool fHasTime; |
| |
| XMLCh* fBuffer; |
| MemoryManager* fMemoryManager; |
| |
| friend class XSValue; |
| }; |
| |
| inline void XMLDateTime::setBuffer(const XMLCh* const aString) |
| { |
| reset(); |
| |
| fEnd = XMLString::stringLen(aString); |
| |
| for (; fEnd > 0; fEnd--) |
| { |
| if (!XMLChar1_0::isWhitespace(aString[fEnd - 1])) |
| break; |
| } |
| |
| if (fEnd > 0) { |
| |
| if (fEnd > fBufferMaxLen) |
| { |
| fMemoryManager->deallocate(fBuffer); |
| fBufferMaxLen = fEnd + 8; |
| fBuffer = (XMLCh*) fMemoryManager->allocate((fBufferMaxLen+1) * sizeof(XMLCh)); |
| } |
| |
| memcpy(fBuffer, aString, (fEnd) * sizeof(XMLCh)); |
| fBuffer[fEnd] = '\0'; |
| } |
| } |
| |
| inline void XMLDateTime::reset() |
| { |
| for ( int i=0; i < TOTAL_SIZE; i++ ) |
| fValue[i] = 0; |
| |
| fMilliSecond = 0; |
| fHasTime = false; |
| fTimeZone[hh] = fTimeZone[mm] = 0; |
| fStart = fEnd = 0; |
| |
| if (fBuffer) |
| *fBuffer = 0; |
| } |
| |
| inline void XMLDateTime::copy(const XMLDateTime& rhs) |
| { |
| for ( int i = 0; i < TOTAL_SIZE; i++ ) |
| fValue[i] = rhs.fValue[i]; |
| |
| fMilliSecond = rhs.fMilliSecond; |
| fHasTime = rhs.fHasTime; |
| fTimeZone[hh] = rhs.fTimeZone[hh]; |
| fTimeZone[mm] = rhs.fTimeZone[mm]; |
| fStart = rhs.fStart; |
| fEnd = rhs.fEnd; |
| |
| if (fEnd > 0) |
| { |
| if (fEnd > fBufferMaxLen) |
| { |
| fMemoryManager->deallocate(fBuffer);//delete[] fBuffer; |
| fBufferMaxLen = rhs.fBufferMaxLen; |
| fBuffer = (XMLCh*) fMemoryManager->allocate((fBufferMaxLen+1) * sizeof(XMLCh)); |
| } |
| |
| memcpy(fBuffer, rhs.fBuffer, (fEnd+1) * sizeof(XMLCh)); |
| } |
| } |
| |
| inline bool XMLDateTime::initParser() |
| { |
| if (!fBuffer || fBuffer[0] == chNull) |
| return false; |
| |
| fStart = 0; // to ensure scan from the very first beginning |
| // in case the pointer is updated accidentally by |
| // someone else. |
| return true; |
| } |
| |
| inline bool XMLDateTime::isNormalized() const |
| { |
| return ( fValue[utc] == UTC_STD ? true : false ); |
| } |
| |
| inline int XMLDateTime::getRetVal(int c1, int c2) |
| { |
| if ((c1 == LESS_THAN && c2 == GREATER_THAN) || |
| (c1 == GREATER_THAN && c2 == LESS_THAN) ) |
| { |
| return INDETERMINATE; |
| } |
| |
| return ( c1 != INDETERMINATE ) ? c1 : c2; |
| } |
| |
| XERCES_CPP_NAMESPACE_END |
| |
| #endif |
