Timestamp.cpp

Go to the documentation of this file.

/*
* Copyright Onix Solutions Limited [OnixS]. All rights reserved. 
* 
* This software owned by Onix Solutions Limited [OnixS] and is protected by copyright law 
* and international copyright treaties. 
* 
* Access to and use of the software is governed by the terms of the applicable ONIXS Software
* Services Agreement (the Agreement) and Customer end user license agreements granting 
* a non-assignable, non-transferable and non-exclusive license to use the software 
* for it's own data processing purposes under the terms defined in the Agreement.
* 
* Except as otherwise granted within the terms of the Agreement, copying or reproduction of any part 
* of this source code or associated reference material to any other location for further reproduction
* or redistribution, and any amendments to this copyright notice, are expressly prohibited. 
*
* Any reproduction or redistribution for sale or hiring of the Software not in accordance with 
* the terms of the Agreement is a violation of copyright law. 
*/

#include <OnixS/SgxTitan/Trading/OUCH/Timestamp.h>

#include <util/Converter.h>

#include <OnixS/Core/Time/Definitions.h>
#include <OnixS/Core/Time/Service.h>

#include "Utils.h"


ONIXS_SGXTITAN_OUCH_NAMESPACE_BEGIN


using namespace std;
using namespace OnixS::Util;


Timestamp::Timestamp()
{
    *this = TimeManager::convert(
        OnixS::Time::DateTime::epoch());
}

Timestamp::Timestamp(
        unsigned int year, Month::Enum month, unsigned int day,
        unsigned int hour, unsigned int minute, unsigned int second,
        unsigned int nanosecond) :
    sinceEpoch_()
{
    *this = TimeManager::convert(
        OnixS::Time::DateTime(
            year, 
            static_cast<OnixS::Time::Month>(month), 
            day, 
            hour, 
            minute, 
            second, 
            OnixS::Time::NanosecondSubsecond(nanosecond)
        )
    );
}

unsigned 
Timestamp::year() const
{
    return TimeManager::convert(*this).year();
}

Month::Enum 
Timestamp::month() const
{
    return static_cast<Month::Enum>(
        TimeManager::convert(*this).month());
}

unsigned int
Timestamp::day() const
{
    return TimeManager::convert(*this).day();
}

void 
Timestamp::date(YearMonthDay& ymd) const
{
    OnixS::Time::YearMonthDay impl;
    TimeManager::convert(*this).getDate(impl);

    ymd.year = impl.year;
    ymd.month = static_cast<Month::Enum>(impl.month);
    ymd.day = impl.day;
}

unsigned int
Timestamp::hour() const
{
    return TimeManager::convert(*this).hour();
}

unsigned int
Timestamp::minute() const
{
    return TimeManager::convert(*this).minute();
}

unsigned int 
Timestamp::second() const
{
    return TimeManager::convert(*this).second();
}

bool
Timestamp::operator ==(
    const Timestamp& other) const
{
    return TimeManager::convert(*this) == 
        TimeManager::convert(other);
}

bool
Timestamp::operator !=(
    const Timestamp& other) const
{
    return TimeManager::convert(*this) != 
        TimeManager::convert(other);
}

bool
Timestamp::operator <(
    const Timestamp& other) const
{
    return TimeManager::convert(*this) < 
        TimeManager::convert(other);
}

void 
Timestamp::toString(
    std::string& str,
    TimestampFormat::Enum format) const
{
    const 
    OnixS::Time::DateTime 
    dateTime = TimeManager::convert(*this);

    switch (format)
    {
    case TimestampFormat::YYYYMMDD:
        OnixS::Time::YYYYMMDDFormatter()(dateTime, str);
        break;

    case TimestampFormat::YYYYMMDDHHMMSS:
        OnixS::Time::YYYYMMDDHHMMSSFormatter()(dateTime, str);
        break;

    case TimestampFormat::YYYYMMDDHHMMSSMsec:
        OnixS::Time::YYYYMMDDHHMMSSmsecFormatter()(dateTime, str);
        break;

    case TimestampFormat::YYYYMMDDHHMMSSNsec:
        OnixS::Time::YYYYMMDDHHMMSSnsecFormatter()(dateTime, str);
        break;
    }
}

Timestamp 
Timestamp::utcNow()
{
    return TimeManager::convert(
        OnixS::Time::Accurate::utcNow());
}

Timestamp 
Timestamp::now()
{
    return TimeManager::convert(
        OnixS::Time::Accurate::now());
}

Timestamp 
Timestamp::parse(
    const std::string &str,
    TimestampFormat::Enum format)
{
    bool succeeded = false;
    OnixS::Time::DateTime dateTime;

    switch (format)
    {
    case TimestampFormat::YYYYMMDD:
        {
            succeeded = 
                OnixS::Time::YYYYMMDDFormatter()(
                    str.data(), str.size(), dateTime);
        }
        break;

    case TimestampFormat::YYYYMMDDHHMMSS:
        {
            succeeded = 
                OnixS::Time::YYYYMMDDHHMMSSFormatter()(
                    str.data(), str.size(), dateTime);
        }
        break;

    case TimestampFormat::YYYYMMDDHHMMSSMsec:
        {
            succeeded = 
                OnixS::Time::YYYYMMDDHHMMSSmsecFormatter()(
                    str.data(), str.size(), dateTime);
        }
        break;

    case TimestampFormat::YYYYMMDDHHMMSSNsec:
        {
            succeeded = 
                OnixS::Time::YYYYMMDDHHMMSSnsecFormatter()(
                    str.data(), str.size(), dateTime);
        }
        break;
    }

    if (succeeded)
        return TimeManager::convert(dateTime);

    std::string exceptionReason;

    exceptionReason += "Cannot parse timestamp [str=";
    exceptionReason += str;
    exceptionReason += "]. ";

    throw OnixS::DomainException(exceptionReason);
}

Timestamp
Timestamp::parse (
       unsigned long long numericPresentation,
       TimestampFormat::Enum format)
{
    switch (format)
    {
    case TimestampFormat::YYYYMMDD:
        {
            const unsigned int day = static_cast<unsigned int>((numericPresentation) % 100);

            const Month::Enum month = static_cast<Month::Enum>((numericPresentation /= 100) % 100);

            const unsigned int year = static_cast<unsigned int>(numericPresentation / 100);

            return Timestamp(year, month, day);
        }

    case TimestampFormat::YYYYMMDDHHMMSS:
    case TimestampFormat::YYYYMMDDHHMMSSMsec:
    case TimestampFormat::YYYYMMDDHHMMSSNsec:
    default:
        break;
    }

    std::string exceptionReason;

    exceptionReason += "Cannot parse timestamp [str=";
    exceptionReason += i2str(numericPresentation);
    exceptionReason += "]. ";

    throw OnixS::DomainException(exceptionReason);
}

Timestamp 
Timestamp::epoch()
{
    return TimeManager::convert(OnixS::Time::DateTime::epoch());
}

unsigned int
Timestamp::millisecond() const
{
    BOOST_ASSERT(sinceEpoch_.milliseconds() > 0);
    return static_cast<unsigned int>(sinceEpoch_.milliseconds());
}

unsigned int
Timestamp::microsecond() const
{
    BOOST_ASSERT(sinceEpoch_.microseconds() > 0);
    return static_cast<unsigned int>(sinceEpoch_.microseconds());
}

unsigned int
Timestamp::nanosecond() const
{
    BOOST_ASSERT(sinceEpoch_.nanoseconds() > 0);
    return static_cast<unsigned int>(sinceEpoch_.nanoseconds());
}


}}}}