Time.cpp

Go to the documentation of this file.

#include "PKIFException.h"
#include "PKIFCommonErrors.h"
#include "ASN1Errors.h"
#include "PKIFTime.h"
#include "Duration.h"
#include "ASN1Helper.h"
#include "PKIX1Implicit88.h"
#include "PKIX1Explicit88.h"

#include "boost/numeric/conversion/cast.hpp"

using boost::numeric_cast;
using boost::bad_numeric_cast;

#include "boost/date_time/posix_time/posix_time.hpp"

_CACDayOfMonthLimitType _CACDayOfMonthLimit[] = {
    {  0, false }, // Offset starts at 1
    { 31, false }, // Jan
    { 28, true  }, // Feb
    { 31, false }, // Mar
    { 30, false }, // Apr
    { 31, false }, // May
    { 30, false }, // Jun
    { 31, false }, // Jul
    { 31, false }, // Aug
    { 30, false }, // Sep
    { 31, false }, // Oct
    { 30, false }, // Nov
    { 31, false }  // Dec
};

struct CPKIFTimeImpl {
    boost::posix_time::ptime m_time;
};


CPKIFTimePtr CPKIFTime::CurrentTime()
{
    CPKIFTime* time = new CPKIFTime;

    time->m_impl->m_time = boost::posix_time::second_clock::universal_time();

    return CPKIFTimePtr(time);
}
int getInt(
    CPKIFStringPtr& str, 
    int size)
{
    int theInt = atoi(str->substr(0,size).c_str());
    CPKIFStringPtr tmp(new std::string(str->substr(size)));
    str = tmp;
    return theInt;
}
void fromUtcTime(
    const char* time_, 
    CPKIFTime& time)
{
    if(12 > strlen(time_))
        throw CPKIFException(TOOLKIT_ASN, ASN1_INVALID_TIME);
    // XXX TODO: This does not appear to handle offsets
    CPKIFStringPtr temp(new std::string(time_));
    int year = getInt(temp, 2);
    if (year < 50)
    {
        year += 2000;
    }
    else
    {
        year += 1900;
    }
    int month = getInt(temp, 2);
    int day = getInt(temp, 2);
    int hour = getInt(temp, 2);
    int minute = getInt(temp, 2);
    int second = getInt(temp, 2);
    time.set(year, month, day, hour, minute, second);
}
void fromGenTime(
    const char* time_, 
    CPKIFTime& time)
{
    if(14 > strlen(time_))
        throw CPKIFException(TOOLKIT_ASN, ASN1_INVALID_TIME);

    CPKIFStringPtr temp(new std::string(time_));
    int year = getInt(temp, 4);
    int month = getInt(temp, 2);
    int day = getInt(temp, 2);
    int hour = getInt(temp, 2);
    int minute = getInt(temp, 2);
    int second = getInt(temp, 2);
    time.set(year, month, day, hour, minute, second);
}

//
// CPKIFTime - Default constructor
// 
CPKIFTime::CPKIFTime()
:m_impl(new CPKIFTimeImpl)
{
}

//
// CPKIFTime - Copy Constructor
//
CPKIFTime::CPKIFTime(const CPKIFTime& date_)
:m_impl(new CPKIFTimeImpl)
{
    m_impl->m_time = date_.m_impl->m_time;
}
CPKIFTime::CPKIFTime(
    const char *time, 
    TimeType type)
    :m_impl(new CPKIFTimeImpl)
{

    if (type == UTCTIME)
    {
        //fromUtcTime(time.u.utcTime, *this);
        fromUtcTime(time, *this);
    }
    else
    {
        fromGenTime(time, *this);
        //fromGenTime(time.u.generalTime, *this);
    }
}
CPKIFTime::CPKIFTime(const char* time)
:m_impl(new CPKIFTimeImpl)
{
    //Added NULL check 3/7/2005 Armen
    if(time == NULL)
    {
        CPKIFTimePtr temp = CurrentTime();
        fromGenTime(temp->GetTime(), *this);
    }
    else
        fromGenTime(time, *this);
}

//
// CPKIFTime - Destructor
// 
CPKIFTime::~CPKIFTime()
{
    if(m_impl) {
        delete m_impl;
        m_impl = 0;
    }
}

//---------------------------------------------------------------------------
// Properties
//---------------------------------------------------------------------------

//
// year - returns the year
// 
int CPKIFTime::year() const
{
    return m_impl->m_time.date().year();
}

//
// month - returns the month of the year (1 = January, 12=December)
//
int CPKIFTime::month() const
{
    return m_impl->m_time.date().month();
}

//
// dayOfMonth - returns the day of the month (1 = first day of month, 31= 31st day)
//
int CPKIFTime::dayOfMonth() const
{
    return m_impl->m_time.date().day();
}

int CPKIFTime::hours() const
{
    return m_impl->m_time.time_of_day().hours();
}

//
// minutes - returns the minutes into the hour (0-59)
// 
int CPKIFTime::minutes() const
{
    return m_impl->m_time.time_of_day().minutes();
}

//
// seconds - returns the seconds into the minute (0-59)
// 
int CPKIFTime::seconds() const
{
    return m_impl->m_time.time_of_day().seconds();
}

//@b Interface: External
//
//This function returns an instance of CPKIFTIme containing the time value representing the beginning of the day of the 
//time value held by the instance on which this function was invoked.
//
//@return An instance of CPKIFTIme containing the time value representing the beginning of the day of the time value held by the instance on which this function was invoked.
//*/
//CPKIFTime CPKIFTime::startOfDay() const
//{
//  // Get new instance based on the same time as the receiver
//  CPKIFTime time(*this);
//
//  // Make implementation writable
//  time.impl() = impl()->writableCopy();
//
//  // Move time to start of day
//  time.impl()->startOfDay();
//
//  return time;
//}

//@b Interface: External
//
//This function returns an instance of CPKIFTIme containing the time value representing the beginning
//of the week of the time value held by the instance on which this function was invoked.
//
//@return An instance of CPKIFTIme containing the time value representing the beginning of the week of the time value held by the instance on which this function was invoked.
//*/
//CPKIFTime CPKIFTime::startOfWeek() const
//{
//  // Get new instance based on the same time as the receiver
//  CPKIFTime time(*this);
//
//  // Make implementation writable
//  time.impl() = impl()->writableCopy();
//
//  // Move time to start of day
//  time.impl()->startOfWeek();
//
//  return time;
//}

//@b Interface: External
//
//This function returns an instance of CPKIFTIme containing the time value representing the beginning of
//the month of the time value held by the instance on which this function was invoked.
//
//@return An instance of CPKIFTIme containing the time value representing the beginning of the month of the time value held by the instance on which this function was invoked.
//*/
//CPKIFTime CPKIFTime::startOfMonth() const
//{
//  // Get new instance based on the same time as the receiver
//  CPKIFTime time(*this);
//
//  // Make implementation writable
//  time.impl() = impl()->writableCopy();
//
//  // Move time to start of day
//  time.impl()->startOfMonth();
//
//  return time;
//}

//@b Interface: External
//
//This function returns an instance of CPKIFTIme containing the time value representing the beginning of 
//the year of the time value held by the instance on which this function was invoked.
//
//@return An instance of CPKIFTIme containing the time value representing the beginning of the year of the time value held by the instance on which this function was invoked.
//*/
//CPKIFTime CPKIFTime::startOfYear() const
//{
//  // Get new instance based on the same time as the receiver
//  CPKIFTime time(*this);
//
//  // Make implementation writable
//  time.impl() = impl()->writableCopy();
//
//  // Move time to start of day
//  time.impl()->startOfYear();
//
//  return time;
//}

//---------------------------------------------------------------------------
// Methods
//---------------------------------------------------------------------------

//
// print - returns a string representing the time held by the receiver
// 
#include <iostream>
#include <sstream>
#include <bitset>
#include <iomanip>
const char* CPKIFTime::GetTime() const
{
    if(m_timeStr == (std::string*)NULL)
    {
        std::ostringstream os;
        os  << m_impl->m_time.date().year() <<
            std::setw(2) << std::setfill('0') << m_impl->m_time.date().month().as_number() << 
            std::setw(2) << std::setfill('0') << m_impl->m_time.date().day() << 
            std::setw(2) << std::setfill('0') << m_impl->m_time.time_of_day().hours() << 
            std::setw(2) << std::setfill('0') << m_impl->m_time.time_of_day().minutes() <<
            std::setw(2) << std::setfill('0') << 
            std::setw(2) << std::setfill('0') << 
                m_impl->m_time.time_of_day().seconds() << "Z" << std::ends; //added endl - 7/19/2004

        CPKIFStringPtr tmpStr(new std::string(os.str()));

        CPKIFTime* nonConstCACTime = const_cast<CPKIFTime*>(this);
        nonConstCACTime->m_timeStr = tmpStr;
    }

    return m_timeStr->c_str();
}

//
// set - adjust the current instance of time according to the provided gregorian date/time
// 
void CPKIFTime::set(
    int  year_, 
    int month_, 
    int dom_, 
    int hours_, 
    int minutes_, 
    int seconds_ )
{
    try {
        CPKIFStringPtr emptyStr;
        m_timeStr = emptyStr;
    
        boost::gregorian::date date(year_,month_,dom_);
        boost::posix_time::time_duration td(hours_,minutes_,seconds_);
        m_impl->m_time = boost::posix_time::ptime(date,td);
    } catch( std::exception& e) {
        throw CPKIFException(TOOLKIT_ASN, ASN1_INVALID_TIME, e.what());
    }

}

//@b Interface: External
//
//This function is used to set the value of an instance of CPKIFTime.
//
//@return None
//
//@exception CPKIFException(ASN1_INVALID_TIME)
//*/
//void CPKIFTime::setJulian(
//  //![in] Integer containing the year value to set
//  int  year_, 
//  //![in] Integer containing the julian day value to set (1-366)
//  int julianDay_,
//  //![in] Integer containing the hours into the day value to set (0-23)
//  int hours_, 
//  //![in] Integer containing the minutes into the hour value to set (0-59)
//  int minutes_, 
//  //![in] Integer containing the seconds into the minute value to set (0-59)
//  int seconds_  )
//{
//  CPKIFStringPtr emptyStr;
//  m_timeStr = emptyStr;
//
//  // Validate date
//  if( !_CPKIFTimeImpl::isJulianDateValid(year_, julianDay_) )
//  {
//      throw CPKIFException(TOOLKIT_ASN, ASN1_INVALID_TIME);
//  }
//
//  // Validate time
//  if( !_CPKIFTimeImpl::isTimeValid(hours_, minutes_, seconds_) )
//  {
//      throw CPKIFException(TOOLKIT_ASN, ASN1_INVALID_TIME);
//  }
//
//  // Get writable copy
//  impl() = impl()->writableCopy();
//
//  // Set variables
//  impl()->set(year_, 1, 1, hours_, minutes_, seconds_);
//  impl()->m_absoluteTime += (julianDay_ - 1);
//  impl()->updateFromTime();
//}

//@b Interface: External
//
//This function is used to add a specified number of days to the time value held by an instance of CPKIFTime.
//
//@return None
//*/
//void CPKIFTime::addDays( 
//  //![in] Integer containing the number of days to add to the time value
//  int days_ )
//{
//  CPKIFStringPtr emptyStr;
//  m_timeStr = emptyStr;
//
//  // Get writable copy
//  impl() = impl()->writableCopy();
//
//  // Add number of days
//  impl()->m_absoluteTime += days_;
//  impl()->updateFromTime();
//}

//@b Interface: External
//
//This function is used to add a specified number of years to the time value held by an instance of CPKIFTime.
//
//@return None
//*/
//void CPKIFTime::addYears( 
//  //![in] Integer containing the number of years to add
//  int years_ )
//{
//  CPKIFStringPtr emptyStr;
//  m_timeStr = emptyStr;
//
//  // Get writable copy
//  impl() = impl()->writableCopy();
//
//  // Add a number of years
//  impl()->addYears( years_ );
//}


//---------------------------------------------------------------------------
// operators
//---------------------------------------------------------------------------

//
// operator =(const CPKIFTime&), assignment operator
//
CPKIFTime& CPKIFTime::operator =(
    const CPKIFTime& time_)
{
    CPKIFStringPtr emptyStr;
    m_timeStr = emptyStr;
    
    // Ensure this is a different implementation
    if( m_impl != time_.m_impl )
    {
        m_impl->m_time = time_.m_impl->m_time;
    }

    return *this;
}

//
// operator +=(const CPKIFDuration& duration_) - add a duration to receiver
//
CPKIFTime& CPKIFTime::operator+=(
    const CPKIFDuration& duration_)
{
    CPKIFStringPtr emptyStr;
    m_timeStr = emptyStr;

    long lSecs = 0;

    try 
    {
        lSecs = numeric_cast<long>(duration_.asSeconds());
    }
    catch(bad_numeric_cast &) 
    {
        throw CPKIFException(TOOLKIT_ASN, COMMON_INVALID_INPUT, "Double not fit for a long.");
    }

    m_impl->m_time += boost::posix_time::time_duration(boost::posix_time::seconds(lSecs));

    return *this;
}

//
// operator -=(const CPKIFDuration& duration_) - substract a duration from receiver
//
CPKIFTime& CPKIFTime::operator-=(
    const CPKIFDuration& duration_)
{
    CPKIFStringPtr emptyStr;
    m_timeStr = emptyStr;

    long lSecs = 0;

    try 
    {
        lSecs = numeric_cast<long>(duration_.asSeconds());
    }
    catch(bad_numeric_cast &) 
    {
        throw CPKIFException(TOOLKIT_ASN, COMMON_INVALID_INPUT, "Double not fit for a long.");
    }

    m_impl->m_time -= boost::posix_time::time_duration(boost::posix_time::seconds(lSecs));

    return *this;
}

//
// operator +(const CPKIFDuration& duration_) - add receiver with duration and return result
//
CPKIFTime CPKIFTime::operator+(
    const CPKIFDuration& duration_) const
{
    CPKIFTime time(*this);
    long lSecs = 0;

    try 
    {
        lSecs = numeric_cast<long>(duration_.asSeconds());
    }
    catch(bad_numeric_cast &) 
    {
        throw CPKIFException(TOOLKIT_ASN, COMMON_INVALID_INPUT, "Double not fit for a long.");
    }

    time.m_impl->m_time += boost::posix_time::time_duration(boost::posix_time::seconds(lSecs));
    return time;
}

//
// operator -(const CPKIFDuration& duration_) - substract duration from receiver and return result
//
CPKIFTime CPKIFTime::operator-(
    const CPKIFDuration& duration_) const
{
    CPKIFTime time(*this);
    long lSecs = 0;

    try 
    {
        lSecs = numeric_cast<long>(duration_.asSeconds());
    }
    catch(bad_numeric_cast &) 
    {
        throw CPKIFException(TOOLKIT_ASN, COMMON_INVALID_INPUT, "Double not fit for a long.");
    }

    time.m_impl->m_time -= boost::posix_time::time_duration(boost::posix_time::seconds(lSecs));
    return time;
}

//
// operator -(const CPKIFTime& time_) - get duration by substracting two times
//
CPKIFDuration CPKIFTime::operator-(
    const CPKIFTime& time_) const
{
    CPKIFDuration duration;
    duration.setSeconds(boost::posix_time::time_duration(m_impl->m_time - time_.m_impl->m_time).total_seconds());
    //duration.setDays( impl()->m_absoluteTime - time_.impl()->m_absoluteTime );
    return duration;
}

//
// operator == - true if the times are exactly equivalent
// 
bool CPKIFTime::operator ==(
    const CPKIFTime& time_) const
{
    return( m_impl->m_time == time_.m_impl->m_time );
}

//
// operator != - true if the times are not equal
// 
bool CPKIFTime::operator !=(
    const CPKIFTime& time_) const
{
    return( m_impl->m_time != time_.m_impl->m_time );
}

//
// operator < - true if the specified time is later (greater) than this
// 
bool CPKIFTime::operator <(
    const CPKIFTime& time_) const
{
    return( m_impl->m_time < time_.m_impl->m_time );
}

//
// operator > - true if the specified time is before (less) than this
// 
bool CPKIFTime::operator >(
    const CPKIFTime& time_) const
{
    return( m_impl->m_time > time_.m_impl->m_time );
}

//
// operator >= - return true if the specified time is the same or before this
//
bool CPKIFTime::operator >=(
    const CPKIFTime& time_) const
{
    return( m_impl->m_time >= time_.m_impl->m_time );
}

//
// operator <= - return true if the specified time is the same or after this
// 
bool CPKIFTime::operator <=(
    const CPKIFTime& time_) const
{
    return( m_impl->m_time <= time_.m_impl->m_time );
}