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 <util/Converter.h>

#include <OnixS/Core/Time/DateTime.h>
#include <OnixS/Core/Time/Operators.h>
#include <OnixS/Core/Time/Service.h>

#include <OnixS/HandlerCore/TimeHelper.h>

#include <OnixS/SgxTitan/MarketData/Itch/Timestamp.h>

#include "NamespaceHelper.h"

using namespace std;
using namespace OnixS::Util;
using OnixS::HandlerCore::Common::TimeHelper;

ONIXS_HANDLER_NAMESPACE_BEGIN

namespace
{
    inline
    OnixS::Time::DateTime
    convert(const Timestamp& time)
    {
        return
            OnixS::Time::DateTime(
                OnixS::Time::TimeSpan(time.sinceEpoch().totalSeconds(),
                                      OnixS::Time::NanosecondSubseconds(time.sinceEpoch().nanoseconds())));
    }
}


Timestamp::Timestamp()
{
    *this = TimeHelper::convert<Timestamp>(
        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 = TimeHelper::convert<Timestamp>(
        OnixS::Time::DateTime(
            year,
            static_cast<OnixS::Time::Month>(month),
            day,
            hour,
            minute,
            second,
            OnixS::Time::NanosecondSubsecond(nanosecond)));
}

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

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

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

void
    Timestamp::date(YearMonthDay& ymd) const
{
    OnixS::Time::YearMonthDay impl;
    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 convert(*this).hour();
}

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

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

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

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

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

void
Timestamp::toString(
std::string& str,
TimestampFormat::Enum format) const
{
    const
    OnixS::Time::DateTime
        dateTime = 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 TimeHelper::convert<Timestamp>(
        OnixS::Time::Accurate::utcNow());
}

Timestamp
Timestamp::now()
{
    return TimeHelper::convert<Timestamp>(
        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 TimeHelper::convert<Timestamp>(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 TimeHelper::convert<Timestamp>(OnixS::Time::DateTime::epoch());
}



ONIXS_HANDLER_NAMESPACE_END