-/*
- * Copyright 2001-2006 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>
-#include <xercesc/util/NumberFormatException.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
+ }
}
// ---------------------------------------------------------------------------
//fStart is supposed to point to 'T'
if (fBuffer[fStart++] != DATETIME_SEPARATOR)
- ThrowXML1(SchemaDateTimeException
- , XMLExcepts::DateTime_gDay_invalid
- , fBuffer);
+ throw XMLParserException("Invalid separator between date and time.");
getTime();
validateDateTime();
fBuffer[1] != DATE_SEPARATOR ||
fBuffer[2] != DATE_SEPARATOR )
{
- ThrowXML1(SchemaDateTimeException
- , XMLExcepts::DateTime_gDay_invalid
- , fBuffer);
+ throw XMLParserException("Invalid character in date.");
}
//initialize values
int sign = findUTCSign(DAY_SIZE);
if ( sign < 0 )
{
- ThrowXML1(SchemaDateTimeException
- , XMLExcepts::DateTime_gDay_invalid
- , fBuffer);
+ throw XMLParserException("Invalid character in date.");
}
else
{
if (fBuffer[0] != DATE_SEPARATOR ||
fBuffer[1] != DATE_SEPARATOR )
{
- ThrowXML1(SchemaDateTimeException
- , XMLExcepts::DateTime_gMth_invalid
- , fBuffer);
+ throw XMLParserException("Invalid character in date.");
}
//set constants
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
int sign = findUTCSign(fStart);
if ( sign < 0 )
{
- ThrowXML1(SchemaDateTimeException
- , XMLExcepts::DateTime_gMth_invalid
- , fBuffer);
+ throw XMLParserException("Invalid character in date.");
}
else
{
fBuffer[1] != DATE_SEPARATOR ||
fBuffer[4] != DATE_SEPARATOR )
{
- ThrowXML1(SchemaDateTimeException
- , XMLExcepts::DateTime_gMthDay_invalid
- , fBuffer);
+ throw XMLParserException("Invalid character in date.");
}
//initialize
fValue[CentYear] = YEAR_DEFAULT;
- fValue[Month] = parseInt(2, 4);
+ fValue[Month] = parseInt(2, 4);
fValue[Day] = parseInt(5, 7);
if ( MONTHDAY_SIZE < fEnd )
int sign = findUTCSign(MONTHDAY_SIZE);
if ( sign<0 )
{
- ThrowXML1(SchemaDateTimeException
- , XMLExcepts::DateTime_gMthDay_invalid
- , fBuffer);
+ throw XMLParserException("Invalid character in date.");
}
else
{
if ( (c != DURATION_STARTER) &&
(c != chDash) )
{
- ThrowXML1(SchemaDateTimeException
- , XMLExcepts::DateTime_dur_Start_dashP
- , fBuffer);
+ throw XMLParserException("Invalid character in time.");
}
// 'P' must ALWAYS be present in either case
if ( (c == chDash) &&
(fBuffer[fStart++]!= DURATION_STARTER ))
{
- ThrowXML1(SchemaDateTimeException
- , XMLExcepts::DateTime_dur_noP
- , fBuffer);
+ throw XMLParserException("Invalid character in time.");
}
// java code
//
if (indexOf(fStart, fEnd, chDash) != NOT_FOUND)
{
- ThrowXML1(SchemaDateTimeException
- , XMLExcepts::DateTime_dur_DashNotFirst
- , fBuffer);
+ throw XMLParserException("Invalid character in time.");
}
//at least one number and designator must be seen after P
if ( (fEnd == endDate) && // 'T' absent
(fStart != fEnd) ) // something after Day
{
- ThrowXML1(SchemaDateTimeException
- , XMLExcepts::DateTime_dur_inv_b4T
- , fBuffer);
+ throw XMLParserException("Invalid character in time.");
}
if ( fEnd != endDate ) // 'T' present
/***
* 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 ( mlsec+1 == end )
{
- ThrowXML1(SchemaDateTimeException
- , XMLExcepts::DateTime_dur_inv_seconds
- , fBuffer);
+ throw XMLParserException("Invalid character in time.");
}
fValue[Second] = negate * parseInt(fStart, mlsec);
if ( (fStart != fEnd) ||
fBuffer[--fStart] == DATETIME_SEPARATOR )
{
- ThrowXML1(SchemaDateTimeException
- , XMLExcepts::DateTime_dur_NoTimeAfterT
- , fBuffer);
+ throw XMLParserException("Invalid character in time.");
}
}
if ( !designator )
{
- ThrowXML1(SchemaDateTimeException
- , XMLExcepts::DateTime_dur_NoElementAtAll
- , fBuffer);
+ throw XMLParserException("Invalid character in time.");
}
}
// Ensure enough chars in buffer
if ( (fStart+YMD_MIN_SIZE) > fEnd)
- ThrowXML1(SchemaDateTimeException
- , XMLExcepts::DateTime_date_incomplete
- , fBuffer);
+ throw XMLParserException("Date/time string not complete.");
getYearMonth(); // Scan YearMonth and
// fStart point to the next '-'
if (fBuffer[fStart++] != DATE_SEPARATOR)
{
- ThrowXML1(SchemaDateTimeException
- , XMLExcepts::DateTime_date_invalid
- , fBuffer);
- //("CCYY-MM must be followed by '-' sign");
+ throw XMLParserException("CCYY-MM must be followed by '-' sign.");
}
fValue[Day] = parseInt(fStart, fStart+2);
// Ensure enough chars in buffer
if ( (fStart+TIME_MIN_SIZE) > fEnd)
- ThrowXML1(SchemaDateTimeException
- , XMLExcepts::DateTime_time_incomplete
- , fBuffer);
- //"Imcomplete Time Format"
+ throw XMLParserException("Incomplete Time Format.");
// check (fixed) format first
if ((fBuffer[fStart + 2] != TIME_SEPARATOR) ||
(fBuffer[fStart + 5] != TIME_SEPARATOR) )
{
- ThrowXML1(SchemaDateTimeException
- , XMLExcepts::DateTime_time_invalid
- , fBuffer);
- //("Error in parsing time" );
+ throw XMLParserException("Error in parsing time.");
}
//
// make sure we have some thing between the '.' and fEnd
if (fStart >= fEnd)
{
- ThrowXML1(SchemaDateTimeException
- , XMLExcepts::DateTime_ms_noDigit
- , fBuffer);
- //("ms shall be present once '.' is present" );
+ throw XMLParserException("ms should be present once '.' is present.");
}
if ( sign == NOT_FOUND )
}
else if(sign == 0 || sign != fStart)
{
- // seconds has more than 2 digits
- ThrowXML1(SchemaDateTimeException
- , XMLExcepts::DateTime_min_invalid
- , fBuffer);
+ throw XMLParserException("Seconds has more than 2 digits.");
}
//parse UTC time zone (hh:mm)
// Ensure enough chars in buffer
if ( (fStart+YMONTH_MIN_SIZE) > fEnd)
- ThrowXML1(SchemaDateTimeException
- , XMLExcepts::DateTime_ym_incomplete
- , fBuffer);
- //"Imcomplete YearMonth Format";
+ throw XMLParserException("Incomplete YearMonth Format.");
// skip the first leading '-'
int start = ( fBuffer[0] == chDash ) ? fStart + 1 : fStart;
//
int yearSeparator = indexOf(start, fEnd, DATE_SEPARATOR);
if ( yearSeparator == NOT_FOUND)
- ThrowXML1(SchemaDateTimeException
- , XMLExcepts::DateTime_ym_invalid
- , fBuffer);
- //("Year separator is missing or misplaced");
+ throw XMLParserException("Year separator is missing or misplaced.");
fValue[CentYear] = parseIntYear(yearSeparator);
fStart = yearSeparator + 1; //skip the '-' and point to the first M
//gonna check we have enough byte for month
//
if ((fStart + 2) > fEnd )
- ThrowXML1(SchemaDateTimeException
- , XMLExcepts::DateTime_ym_noMonth
- , fBuffer);
- //"no month in buffer"
+ throw XMLParserException("No month in buffer.");
fValue[Month] = parseInt(fStart, yearSeparator + 3);
fStart += 2; //fStart points right after the MONTH
int sign = findUTCSign(fStart);
if ( sign < 0 )
{
- ThrowXML1(SchemaDateTimeException
- , XMLExcepts::DateTime_tz_noUTCsign
- , fBuffer);
- //("Error in month parsing");
+ throw XMLParserException("Error in month parsing.");
}
else
{
{
if ((sign + 1) != fEnd )
{
- ThrowXML1(SchemaDateTimeException
- , XMLExcepts::DateTime_tz_stuffAfterZ
- , fBuffer);
- //"Error in parsing time zone");
- }
+ throw XMLParserException("Error in parsing time zone.");
+ }
- return;
+ return;
}
//
if ( ( ( sign + TIMEZONE_SIZE + 1) != fEnd ) ||
( fBuffer[sign + 3] != TIMEZONE_SEPARATOR ) )
{
- ThrowXML1(SchemaDateTimeException
- , XMLExcepts::DateTime_tz_invalid
- , fBuffer);
- //("Error in parsing time zone");
+ 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;
}
// or reporting an error message should be sufficient?
if ( fValue[CentYear] == 0 )
{
- ThrowXML1(SchemaDateTimeException
- , XMLExcepts::DateTime_year_zero
- , fBuffer);
- //"The year \"0000\" is an illegal year value");
+ throw XMLParserException("The year \"0000\" is an illegal year value");
}
if ( fValue[Month] < 1 ||
fValue[Month] > 12 )
{
- ThrowXML1(SchemaDateTimeException
- , XMLExcepts::DateTime_mth_invalid
- , fBuffer);
- //"The month must have values 1 to 12");
+ throw XMLParserException("The month must have values 1 to 12");
}
//validate days
if ( fValue[Day] > maxDayInMonthFor( fValue[CentYear], fValue[Month]) ||
fValue[Day] == 0 )
{
- ThrowXML1(SchemaDateTimeException
- , XMLExcepts::DateTime_day_invalid
- , fBuffer);
- //"The day must have values 1 to 31");
+ throw XMLParserException("The day must have values 1 to 31");
}
//validate hours
(fValue[Second] !=0) ||
(fMiliSecond !=0))))
{
- ThrowXML1(SchemaDateTimeException
- , XMLExcepts::DateTime_hour_invalid
- , fBuffer);
- //("Hour must have values 0-23");
+ throw XMLParserException("Hour must have values 0-23");
}
//validate minutes
if ( fValue[Minute] < 0 ||
fValue[Minute] > 59 )
{
- ThrowXML1(SchemaDateTimeException
- , XMLExcepts::DateTime_min_invalid
- , fBuffer);
- //"Minute must have values 0-59");
+ throw XMLParserException("Minute must have values 0-59");
}
//validate seconds
if ( fValue[Second] < 0 ||
fValue[Second] > 60 )
{
- ThrowXML1(SchemaDateTimeException
- , XMLExcepts::DateTime_second_invalid
- , fBuffer);
- //"Second must have values 0-60");
+ throw XMLParserException("Second must have values 0-60");
}
//validate time-zone hours
if ( (abs(fTimeZone[hh]) > 14) ||
((abs(fTimeZone[hh]) == 14) && (fTimeZone[mm] != 0)) )
{
- ThrowXML1(SchemaDateTimeException
- , XMLExcepts::DateTime_tz_hh_invalid
- , fBuffer);
- //"Time zone should have range -14..+14");
+ throw XMLParserException("Time zone should have range -14..+14");
}
//validate time-zone minutes
if ( abs(fTimeZone[mm]) > 59 )
{
- ThrowXML1(SchemaDateTimeException
- , XMLExcepts::DateTime_min_invalid
- , fBuffer);
- //("Minute must have values 0-59");
+ throw XMLParserException("Minute must have values 0-59");
}
-
+
return;
}
for (int i=start; i < end; i++) {
if (fBuffer[i] < chDigit_0 || fBuffer[i] > chDigit_9)
- ThrowXML(NumberFormatException, XMLExcepts::XMLNUM_Inv_chars);
+ throw XMLParserException("Invalid non-numeric characters.");
retVal = (retVal * 10) + (unsigned int) (fBuffer[i] - chDigit_0);
}
// check if all chars are valid char
if ( (endptr - nptr) != strLen)
- ThrowXML(NumberFormatException, XMLExcepts::XMLNUM_Inv_chars);
+ throw XMLParserException("Invalid non-numeric characters.");
// we don't check underflow occurs since
// nothing we can do about it.
int length = end - start;
if (length < 4)
{
- ThrowXML1(SchemaDateTimeException
- , XMLExcepts::DateTime_year_tooShort
- , fBuffer);
- //"Year must have 'CCYY' format");
+ throw XMLParserException("Year must have 'CCYY' format");
}
else if (length > 4 &&
fBuffer[start] == chDigit_0)
{
- ThrowXML1(SchemaDateTimeException
- , XMLExcepts::DateTime_year_leadingZero
- , fBuffer);
- //"Leading zeros are required if the year value would otherwise have fewer than four digits;
- // otherwise they are forbidden");
+ throw XMLParserException("Leading zeros are required if the year value would otherwise have fewer than four digits; otherwise they are forbidden.");
}
bool negative = (fBuffer[0] == chDash);
* 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