TimeSpan.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 <sstream>
#include <iomanip>
#include <stdexcept>


#include <OnixS/Core/Time/TimeSpan.h>
#include <OnixS/Core/Time/Operators.h>

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

using namespace std;
using namespace OnixS::SgxTitan::Trading::Ouch;
namespace Core = OnixS::Time;

namespace
{
    inline
        Core::TimeSpan 
        convert(const TimeSpan& timeSpan)
    {
        return Core::TimeSpan(
            timeSpan.totalSeconds(), 
            Core::NanosecondSubseconds(timeSpan.nanoseconds()));
    }

    
    inline 
        TimeSpan 
        convert(const Core::TimeSpan& timeSpan)
    {
        return TimeSpan(
            timeSpan.totalSeconds(), 
            timeSpan.nanoseconds());
    }

    void
        throwBadTimeSpanFormat(
        const std::string& timeSpan)
    {
        throw std::logic_error(std::string("Time format is invalid: ") + timeSpan);
    }
}

const TimeSpan TimeSpan::Zero(0, 0);

TimeSpan::TimeSpan()
: seconds_(0), nanoseconds_(0)
{
}

TimeSpan::TimeSpan(
                   int hours, int minutes, 
                   int seconds, int nanoseconds)
{
    *this = convert(
        Core::TimeSpan(
        0, 
        hours, minutes, 
        seconds, Core::NanosecondSubseconds(nanoseconds)));
}

TimeSpan::TimeSpan(
                   int days, 
                   int hours, int minutes, 
                   int seconds, int nanoseconds)
{
    *this = convert(
        Core::TimeSpan(
        days, 
        hours, minutes, 
        seconds, Core::NanosecondSubseconds(nanoseconds)));
}

TimeSpan::TimeSpan(
                   long long totalSeconds, 
                   int nanoseconds)
{
    const 
        Core::TimeSpan 
        Normalized(totalSeconds, Core::NanosecondSubseconds(nanoseconds));

    seconds_ = Normalized.totalSeconds();
    nanoseconds_ = Normalized.nanoseconds();
}

TimeSpan::TimeSpan(
                   const TimeSpan& other)
                   : seconds_(other.seconds_),
                   nanoseconds_(other.nanoseconds_)
{
}

int 
TimeSpan::days() const
{
    return convert(*this).days();
}

int 
TimeSpan::hours() const
{
    return convert(*this).hours();
}

int 
TimeSpan::minutes() const
{
    return convert(*this).minutes();
}

int 
TimeSpan::seconds() const
{
    return convert(*this).seconds();
}

int 
TimeSpan::milliseconds() const
{
    return convert(*this).milliseconds();
}

int 
TimeSpan::microseconds() const
{
    return convert(*this).microseconds();
}

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

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

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

bool 
    TimeSpan::operator >(
    const TimeSpan& other) const
{
    return convert(*this) > convert(other);
}

TimeSpan& 
TimeSpan::operator +=(
                      const TimeSpan& other)
{
    Core::TimeSpan result(convert(*this));

    result += convert(other);

    return (*this = convert(result));
}


TimeSpan& 
TimeSpan::operator -=(
                      const TimeSpan& other)
{
    Core::TimeSpan result(convert(*this));

    result -= convert(other);

    return (*this = convert(result));
}

TimeSpan&
TimeSpan::operator =(
                     const TimeSpan& other)
{
    seconds_ = other.seconds_;
    nanoseconds_ = other.nanoseconds_;

    return *this;
}

void 
TimeSpan::toString(
                   std::string& str, 
                   TimeSpanFormat format) const
{
    switch (format)
    {
    case TimeSpanFormats::HHMMSS:
        {
            Core::HHMMSSFormatter()(convert(*this), str);
        }
        break;

    case TimeSpanFormats::HHMMSSmsec:
        {
            Core::HHMMSSmsecFormatter()(convert(*this), str);
        }
        break;

    case TimeSpanFormats::SDHHMMSSnsec:
        {
            Core::SDHHMMSSnsecFormatter()(convert(*this), str);
        }
        break;

    default:
        {
            throw std::logic_error("Unknown TimeSpan serialization format specified.");
        }
        break;
    }
}

TimeSpan
TimeSpan::deserialize(const string& str)
{
    Core::TimeSpan parsedSpan;

    if (!Core::TimeSpan::parse(
        str.data(), str.size(), parsedSpan))
    {
        throwBadTimeSpanFormat(str);
    }

    return convert(parsedSpan);
}