-/*
- * Copyright 2001-2007 Internet2
- *
- * Licensed 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
+/**
+ * Licensed to the University Corporation for Advanced Internet
+ * Development, Inc. (UCAID) under one or more contributor license
+ * agreements. See the NOTICE file distributed with this work for
+ * additional information regarding copyright ownership.
+ *
+ * UCAID 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
+ * 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.
+ * 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.
*/
/**
* DateTime.cpp
- *
- * Manipulation of XML date/time data.
+ *
+ * Manipulation of XML date/time data.
*/
/*
#endif
#include <ctime>
+#include <sstream>
#include <assert.h>
#include <xercesc/util/Janitor.hpp>
using namespace xmltooling;
+using namespace xercesc;
using namespace std;
//
temp = DATETIMES[index][Second] + fDuration->fValue[Second];
carry = fQuotient (temp, 60);
fNewDate->fValue[Second] = mod(temp, 60, carry);
-
+
//add minutes
temp = DATETIMES[index][Minute] + fDuration->fValue[Minute] + carry;
carry = fQuotient(temp, 60);
temp = DATETIMES[index][Hour] + fDuration->fValue[Hour] + carry;
carry = fQuotient(temp, 24);
fNewDate->fValue[Hour] = mod(temp, 24, carry);
-
+
fNewDate->fValue[Day] =
DATETIMES[index][Day] + fDuration->fValue[Day] + carry;
}
return resultA;
-
+
}
// ---------------------------------------------------------------------------
return getRetVal(c1, c2);
}
- return XMLDateTime::INDETERMINATE;
+ return XMLDateTime::INDETERMINATE;
}
int DateTime::compareResult(const DateTime* const pDate1
setBuffer(aString);
}
-DateTime::DateTime(time_t epoch)
+DateTime::DateTime(time_t epoch, bool duration)
: fStart(0)
, fEnd(0)
, fBufferMaxLen(0)
, fMiliSecond(0)
, fHasTime(false)
{
+ if (duration) {
+ ostringstream s;
+ if (epoch < 0) {
+ s << "-";
+ epoch = -epoch;
+ }
+ time_t days = epoch / 86400;
+ epoch %= 86400;
+ time_t hours = epoch / 3600;
+ epoch %= 3600;
+ time_t minutes = epoch / 60;
+ epoch %= 60;
+ s << "P" << days << "DT" << hours << "H" << minutes << "M" << epoch << "S";
+ auto_ptr_XMLCh timeptr(s.str().c_str());
+ setBuffer(timeptr.get());
+ }
+ else {
#ifndef HAVE_GMTIME_R
- struct tm* ptime=gmtime(&epoch);
+ struct tm* ptime=gmtime(&epoch);
#else
- struct tm res;
- struct tm* ptime=gmtime_r(&epoch,&res);
+ struct tm res;
+ struct tm* ptime=gmtime_r(&epoch,&res);
#endif
- char timebuf[32];
- strftime(timebuf,32,"%Y-%m-%dT%H:%M:%SZ",ptime);
- auto_ptr_XMLCh timeptr(timebuf);
- setBuffer(timeptr.get());
+ char timebuf[32];
+ strftime(timebuf,32,"%Y-%m-%dT%H:%M:%SZ",ptime);
+ auto_ptr_XMLCh timeptr(timebuf);
+ setBuffer(timeptr.get());
+ }
}
// -----------------------------------------------------------------------
int DateTime::getSign() const
{
- return 0;
+ return fValue[utc];
}
-time_t DateTime::getEpoch() const
+time_t DateTime::getEpoch(bool duration) const
{
- struct tm t;
- t.tm_sec=getSecond();
- t.tm_min=getMinute();
- t.tm_hour=getHour();
- t.tm_mday=getDay();
- t.tm_mon=getMonth()-1;
- t.tm_year=getYear()-1900;
- t.tm_isdst=0;
+ if (duration) {
+ time_t epoch = getSecond() + (60 * getMinute()) + (3600 * getHour()) + (86400 * getDay());
+ if (getMonth())
+ epoch += (((365 * 4) + 1)/48 * 86400);
+ if (getYear())
+ epoch += 365.25 * 86400;
+ return getSign()!=UTC_NEG ? epoch : -epoch;
+ }
+ else {
+ struct tm t;
+ t.tm_sec=getSecond();
+ t.tm_min=getMinute();
+ t.tm_hour=getHour();
+ t.tm_mday=getDay();
+ t.tm_mon=getMonth()-1;
+ t.tm_year=getYear()-1900;
+ t.tm_isdst=0;
#if defined(HAVE_TIMEGM)
- return timegm(&t);
+ return timegm(&t);
#else
- // Windows, and hopefully most others...?
- return mktime(&t) - timezone;
+ // Windows, and hopefully most others...?
+ return mktime(&t) - timezone;
#endif
+ }
}
// ---------------------------------------------------------------------------
fValue[Day] = DAY_DEFAULT;
fValue[Month] = parseInt(2, 4);
- // REVISIT: allow both --MM and --MM-- now.
- // need to remove the following lines to disallow --MM--
- // when the errata is officially in the rec.
+ // REVISIT: allow both --MM and --MM-- now.
+ // need to remove the following lines to disallow --MM--
+ // when the errata is officially in the rec.
fStart = 4;
- if ( fEnd >= fStart+2 && fBuffer[fStart] == DATE_SEPARATOR && fBuffer[fStart+1] == DATE_SEPARATOR )
- {
- fStart += 2;
- }
+ if ( fEnd >= fStart+2 && fBuffer[fStart] == DATE_SEPARATOR && fBuffer[fStart+1] == DATE_SEPARATOR )
+ {
+ fStart += 2;
+ }
//
// parse TimeZone if any
//initialize
fValue[CentYear] = YEAR_DEFAULT;
- fValue[Month] = parseInt(2, 4);
+ fValue[Month] = parseInt(2, 4);
fValue[Day] = parseInt(5, 7);
if ( MONTHDAY_SIZE < fEnd )
/***
* Schema Errata: E2-23
- * at least one digit must follow the decimal point if it appears.
- * That is, the value of the seconds component must conform
- * to the following pattern: [0-9]+(.[0-9]+)?
+ * at least one digit must follow the decimal point if it appears.
+ * That is, the value of the seconds component must conform
+ * to the following pattern: [0-9]+(.[0-9]+)?
*/
if ( mlsec != NOT_FOUND )
{
if ((sign + 1) != fEnd )
{
throw XMLParserException("Error in parsing time zone.");
- }
+ }
- return;
+ return;
}
//
throw XMLParserException("Error in parsing time zone.");
}
- fTimeZone[hh] = parseInt(sign+1, sign+3);
+ fTimeZone[hh] = parseInt(sign+1, sign+3);
fTimeZone[mm] = parseInt(sign+4, fEnd);
-
+
return;
}
{
throw XMLParserException("Minute must have values 0-59");
}
-
+
return;
}
* E2-41
*
* 3.2.7.2 Canonical representation
- *
- * Except for trailing fractional zero digits in the seconds representation,
- * '24:00:00' time representations, and timezone (for timezoned values),
- * the mapping from literals to values is one-to-one. Where there is more
- * than one possible representation, the canonical representation is as follows:
- * redundant trailing zero digits in fractional-second literals are prohibited.
+ *
+ * Except for trailing fractional zero digits in the seconds representation,
+ * '24:00:00' time representations, and timezone (for timezoned values),
+ * the mapping from literals to values is one-to-one. Where there is more
+ * than one possible representation, the canonical representation is as follows:
+ * redundant trailing zero digits in fractional-second literals are prohibited.
* An hour representation of '24' is prohibited. Timezoned values are canonically
- * represented by appending 'Z' to the nontimezoned representation. (All
- * timezoned dateTime values are UTC.)
+ * represented by appending 'Z' to the nontimezoned representation. (All
+ * timezoned dateTime values are UTC.)
*
* .'24:00:00' -> '00:00:00'
* .milisecond: trailing zeros removed
/***
* 3.2.8 time
*
- * . either the time zone must be omitted or,
- * if present, the time zone must be Coordinated Universal Time (UTC) indicated by a "Z".
+ * . either the time zone must be omitted or,
+ * if present, the time zone must be Coordinated Universal Time (UTC) indicated by a "Z".
*
* . Additionally, the canonical representation for midnight is 00:00:00.
*
XMLCh strBuffer[16];
assert(expLen < 16);
XMLString::binToText(fValue[ind], strBuffer, expLen, 10);
- int actualLen = XMLString::stringLen(strBuffer);
+ int actualLen = (int) XMLString::stringLen(strBuffer);
int i;
//append leading zeros
for (i = 0; i < expLen - actualLen; i++)
XMLCh strBuffer[16];
// let's hope we get no years of 15 digits...
XMLString::binToText(fValue[ind], strBuffer, 15, 10);
- int actualLen = XMLString::stringLen(strBuffer);
+ int actualLen = (int) XMLString::stringLen(strBuffer);
// don't forget that years can be negative...
int negativeYear = 0;
if(strBuffer[0] == chDash)
return;
}
+void DateTime::setBuffer(const XMLCh* const aString)
+{
+ reset();
+ fEnd = (int) xercesc::XMLString::stringLen(aString);
+ if (fEnd > 0) {
+ if (fEnd > fBufferMaxLen) {
+ delete[] fBuffer;
+ fBufferMaxLen = fEnd + 8;
+ fBuffer = new XMLCh[fBufferMaxLen+1];
+ }
+ memcpy(fBuffer, aString, (fEnd+1) * sizeof(XMLCh));
+ }
+}
+
+void DateTime::reset()
+{
+ for ( int i=0; i < xercesc::XMLDateTime::TOTAL_SIZE; i++ )
+ fValue[i] = 0;
+
+ fMiliSecond = 0;
+ fHasTime = false;
+ fTimeZone[hh] = fTimeZone[mm] = 0;
+ fStart = fEnd = 0;
+
+ if (fBuffer)
+ *fBuffer = 0;
+}
+
+void DateTime::copy(const DateTime& rhs)
+{
+ for ( int i = 0; i < xercesc::XMLDateTime::TOTAL_SIZE; i++ )
+ fValue[i] = rhs.fValue[i];
+
+ fMiliSecond = rhs.fMiliSecond;
+ 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) {
+ delete[] fBuffer;
+ fBufferMaxLen = rhs.fBufferMaxLen;
+ fBuffer = new XMLCh[fBufferMaxLen+1];
+ }
+ memcpy(fBuffer, rhs.fBuffer, (fEnd+1) * sizeof(XMLCh));
+ }
+}
+
+void DateTime::initParser()
+{
+ fStart = 0; // to ensure scan from the very first beginning
+ // in case the pointer is updated accidentally by someone else.
+}
+
+bool DateTime::isNormalized() const
+{
+ return (fValue[xercesc::XMLDateTime::utc] == xercesc::XMLDateTime::UTC_STD ? true : false);
+}
+
+int DateTime::getRetVal(int c1, int c2)
+{
+ if ((c1 == xercesc::XMLDateTime::LESS_THAN && c2 == xercesc::XMLDateTime::GREATER_THAN) ||
+ (c1 == xercesc::XMLDateTime::GREATER_THAN && c2 == xercesc::XMLDateTime::LESS_THAN))
+ return xercesc::XMLDateTime::INDETERMINATE;
+
+ return (c1 != xercesc::XMLDateTime::INDETERMINATE) ? c1 : c2;
+}
projects / shibboleth / cpp-xmltooling.git / blobdiff