Time.h

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.
//
#pragma once
 
#include <string>
#include <algorithm>
#include <stdexcept>
 
#include <OnixS/CboeCFE/Trading/BOE/ABI.h>
#include <OnixS/CboeCFE/Trading/BOE/Compiler.h>
#include <OnixS/CboeCFE/Trading/BOE/Integral.h>
 
 
namespace OnixS
{
    namespace CboeCFE
    {
        namespace Trading
        {
            namespace BOE
            {

                struct TimeTraits
                {
                    ONIXS_BATS_BOE_CONSTEXPR
                    static Int64 nanosecondsPerDay()
                    {
                        return 86400000000000ll;
                    }

                    ONIXS_BATS_BOE_CONSTEXPR
                    static Int64 nanosecondsPerHour()
                    {
                        return 3600000000000ll;
                    }

                    ONIXS_BATS_BOE_CONSTEXPR
                    static Int64 nanosecondsPerMinute()
                    {
                        return 60000000000ll;
                    }

                    ONIXS_BATS_BOE_CONSTEXPR
                    static Int32 nanosecondsPerSecond()
                    {
                        return 1000000000;
                    }

                    ONIXS_BATS_BOE_CONSTEXPR
                    static Int32 nanosecondsPerMillisecond()
                    {
                        return 1000000;
                    }

                    ONIXS_BATS_BOE_CONSTEXPR
                    static Int32 nanosecondsPerMicrosecond()
                    {
                        return 1000;
                    }

                    ONIXS_BATS_BOE_CONSTEXPR
                    static Int32 hoursPerDay()
                    {
                        return 24;
                    }

                    ONIXS_BATS_BOE_CONSTEXPR
                    static Int32 minutesPerHour()
                    {
                        return 60;
                    }

                    ONIXS_BATS_BOE_CONSTEXPR
                    static Int32 secondsPerMinute()
                    {
                        return 60;
                    }

                    ONIXS_BATS_BOE_CONSTEXPR
                    static Int32 millisecondsPerSecond()
                    {
                        return 1000;
                    }

                    ONIXS_BATS_BOE_CONSTEXPR
                    static Int32 microsecondsPerSecond()
                    {
                        return 1000000;
                    }
                };

                class TimeSpan
                {
                public:
                    typedef Int64 Ticks;

                    typedef Int32 Days;

                    typedef Int32 Hours;

                    typedef Int32 Minutes;

                    typedef Int32 Seconds;

                    typedef Int32 Milliseconds;

                    typedef Int32 Microseconds;

                    typedef Int32 Nanoseconds;

                    explicit TimeSpan(Ticks ticks = 0) ONIXS_BATS_BOE_NOTHROW
                        : ticks_(ticks)
                    {
                    }

                    TimeSpan(
                        Days days,
                        Hours hours,
                        Minutes minutes,
                        Seconds seconds,
                        Nanoseconds nanoseconds)
                        : ticks_(
                            static_cast<Ticks>(days) *
                            TimeTraits::nanosecondsPerDay() +
                            static_cast<Ticks>(hours) *
                            TimeTraits::nanosecondsPerHour() +
                            static_cast<Ticks>(minutes) *
                            TimeTraits::nanosecondsPerMinute() +
                            static_cast<Ticks>(seconds) *
                            TimeTraits::nanosecondsPerSecond() +
                            nanoseconds)
                    {
                    }

                    TimeSpan(
                        Hours hours,
                        Minutes minutes,
                        Seconds seconds,
                        Nanoseconds nanoseconds)
                        : ticks_(
                            static_cast<Ticks>(hours) *
                            TimeTraits::nanosecondsPerHour() +
                            static_cast<Ticks>(minutes) *
                            TimeTraits::nanosecondsPerMinute() +
                            static_cast<Ticks>(seconds) *
                            TimeTraits::nanosecondsPerSecond() +
                            nanoseconds)
                    {
                    }

                    Days days() const
                    {
                        return
                            static_cast<Days>
                            (ticks_ /
                             TimeTraits::nanosecondsPerDay());
                    }

                    Hours hours() const
                    {
                        return
                            static_cast<Hours>(
                                (ticks_ /
                                 TimeTraits::nanosecondsPerHour()) %
                                TimeTraits::hoursPerDay()
                            );
                    }

                    Int32 minutes() const
                    {
                        return
                            static_cast<Minutes>(
                                (ticks_ /
                                 TimeTraits::nanosecondsPerMinute()) %
                                TimeTraits::minutesPerHour()
                            );
                    }

                    Int32 seconds() const
                    {
                        return
                            static_cast<Seconds>(
                                (ticks_ /
                                 TimeTraits::nanosecondsPerSecond()) %
                                TimeTraits::secondsPerMinute()
                            );
                    }

                    Milliseconds milliseconds() const
                    {
                        return
                            static_cast<Milliseconds>
                            ((ticks_ /
                              TimeTraits::nanosecondsPerMillisecond()) %
                             TimeTraits::millisecondsPerSecond()
                            );
                    }

                    Microseconds microseconds() const
                    {
                        return
                            static_cast<Microseconds>
                            ((ticks_ /
                              TimeTraits::nanosecondsPerMicrosecond()) %
                             TimeTraits::microsecondsPerSecond()
                            );
                    }

                    Nanoseconds nanoseconds() const
                    {
                        return
                            static_cast<Nanoseconds>
                            (ticks_ %
                             TimeTraits::nanosecondsPerSecond());
                    }

                    Ticks ticks() const
                    {
                        return ticks_;
                    }

                    TimeSpan&
                    operator +=(
                    const TimeSpan& other)
                    {
                        ticks_ += other.ticks_;
                        return *this;
                    }

                    TimeSpan&
                    operator -=(
                    const TimeSpan& other)
                    {
                        ticks_ -= other.ticks_;
                        return *this;
                    }

                    void
                    swap(TimeSpan& other)
                        ONIXS_BATS_BOE_NOTHROW
                    {
                        std::swap(ticks_, other.ticks_);
                    }
 
                private:
                    Ticks ticks_;
                };

                inline
                bool
                operator ==(
                    const TimeSpan& left,
                    const TimeSpan& right)
                {
                    return left.ticks() == right.ticks();
                }

                inline
                bool
                operator !=(
                    const TimeSpan& left,
                    const TimeSpan& right)
                {
                    return left.ticks() != right.ticks();
                }

                inline
                bool
                operator <(
                    const TimeSpan& left,
                    const TimeSpan& right)
                {
                    return left.ticks() < right.ticks();
                }

                inline
                bool
                operator >(
                    const TimeSpan& left,
                    const TimeSpan& right)
                {
                    return left.ticks() > right.ticks();
                }
 
                // TimeSpan serialization.
 
                // Serializes timespan according to HH:MM:SS pattern.
                ONIXS_CBOE_CFE_BOE_API
                void
                toStrAsHHMMSS(std::string&, TimeSpan);
 
                // Serializes timespan according to HH:MM:SS.sss pattern.
                ONIXS_CBOE_CFE_BOE_API
                void
                toStrAsHHMMSSmsec(std::string&, TimeSpan);
 
                // Serializes timespan according to D.HH:MM:SS.sssssssss pattern.
                ONIXS_CBOE_CFE_BOE_API
                void
                toStrAsSDHHMMSSnsec(std::string&, TimeSpan);

                struct TimeSpanFormat
                {
                    enum Enum
                    {
                        HHMMSS,

                            HHMMSSmsec,

                            SDHHMMSSnsec
                    };
                };
 

                inline
                void toStr(
                    std::string& str,
                    TimeSpan timeSpan,
                    TimeSpanFormat::Enum format =
                    TimeSpanFormat::SDHHMMSSnsec)
                {
                    switch (format)
                    {
                        case TimeSpanFormat::HHMMSS:
                            toStrAsHHMMSS(str, timeSpan);
                            break;
 
                        case TimeSpanFormat::HHMMSSmsec:
                            toStrAsHHMMSSmsec(str, timeSpan);
                            break;
 
                        case TimeSpanFormat::SDHHMMSSnsec:
                            toStrAsSDHHMMSSnsec(str, timeSpan);
                            break;
 
                        default:
                        {
                            throw std::invalid_argument(
                                "Unknown timespan format pattern specified. ");
                        }
                    }
                }

                inline
                std::string toStr(
                    TimeSpan timeSpan,
                    TimeSpanFormat::Enum format =
                    TimeSpanFormat::SDHHMMSSnsec)
                {
                    std::string str;
 
                    toStr(str, timeSpan, format);
 
                    return str;
                }

                struct Month
                {
                    enum Enum
                    {
                        January = 1,
                        February,
                        March,
                        April,
                        May,
                        June,
                        July,
                        August,
                        September,
                        October,
                        November,
                        December
                    };
                };
 

                class Timestamp
                {
                    public:
                    typedef UInt64 Ticks;

                    typedef UInt32 Year;

                    typedef
                    OnixS::CboeCFE::Trading::BOE::Month::Enum
                    Month;

                    typedef UInt32 Day;

                    typedef UInt32 Hour;

                    typedef UInt32 Minute;

                    typedef UInt32 Second;

                    typedef UInt32 Millisecond;

                    typedef UInt32 Microsecond;

                    typedef UInt32 Nanosecond;

                    ONIXS_CBOE_CFE_BOE_API
                    static
                    Timestamp utcNow();

                    ONIXS_CBOE_CFE_BOE_API
                    static
                    Timestamp now();

                    explicit
                    Timestamp(
                        Ticks ticks = 0) ONIXS_BATS_BOE_NOTHROW
                        : sinceEpoch_(ticks)
                    {
                    }

                    Timestamp(
                        Year year,
                        Month month,
                        Day day,
                        Hour hour = 0,
                        Minute minute = 0,
                        Second second = 0,
                        Nanosecond nanosecond = 0)
                        : sinceEpoch_(
                            toTicks(
                                year, month, day,
                                hour, minute, second, nanosecond)
                            )
                    {
                    }

                    Timestamp(
                        const Timestamp& other)
                        : sinceEpoch_(other.sinceEpoch_)
                    {
                    }

                    Year year() const
                    {
                        Year year; Month month; Day day;
 
                        toDate(sinceEpoch_, year, month, day);
 
                        return year;
                    }

                    Month month() const
                    {
                        Year year; Month month; Day day;
 
                        toDate(sinceEpoch_, year, month, day);
 
                        return month;
                    }

                    Day day() const
                    {
                        Year year; Month month; Day day;
 
                        toDate(sinceEpoch_, year, month, day);
 
                        return day;
                    }

                    Hour hour() const
                    {
                        return static_cast<Hour>(time().hours());
                    }

                    Minute minute() const
                    {
                        return static_cast<Minute>(time().minutes());
                    }

                    Second second() const
                    {
                        return static_cast<Second>(time().seconds());
                    }

                    Millisecond millisecond() const
                    {
                        return static_cast<Millisecond>(time().milliseconds());
                    }

                    Microsecond microsecond() const
                    {
                        return static_cast<Microsecond>(time().microseconds());
                    }

                    Nanosecond nanosecond() const
                    {
                        return static_cast<Nanosecond>(time().nanoseconds());
                    }

                    Timestamp date() const
                    {
                        return
                            Timestamp(
                                sinceEpoch_ -
                                sinceEpoch_ %
                                TimeTraits::nanosecondsPerDay());
                    }

                    TimeSpan time() const
                    {
                        return
                            TimeSpan(
                                sinceEpoch_ %
                                TimeTraits::nanosecondsPerDay());
                    }

                    Ticks sinceEpoch() const
                        ONIXS_BATS_BOE_NOTHROW
                    {
                        return sinceEpoch_;
                    }

                    Timestamp&
                    operator =(
                    const Timestamp& other)
                    {
                        sinceEpoch_ = other.sinceEpoch_;
 
                        return *this;
                    }

                    void
                    swap(
                    Timestamp& other)
                    {
                        std::swap(
                            sinceEpoch_,
                            other.sinceEpoch_);
                    }
 
                    private:
                    // Time interval in nanoseconds since the 01-01-1970.
                    Ticks sinceEpoch_;
 
                    // Converts structured date-time into ticks.
                    ONIXS_CBOE_CFE_BOE_API
                    static
                    Ticks toTicks(
                        Year, Month, Day,
                        Hour, Minute, Second,
                        Nanosecond);
 
                    // Extracts date components from ticks. 
                    ONIXS_CBOE_CFE_BOE_API
                    static
                    void toDate(Ticks, Year&, Month&, Day&);
                };
 

                inline
                bool
                operator ==(
                    const Timestamp& left,
                    const Timestamp& right)
                {
                    return (
                        left.sinceEpoch() ==
                        right.sinceEpoch()
                    );
                }

                inline
                bool
                operator !=(
                    const Timestamp& left,
                    const Timestamp& right)
                {
                    return (
                        left.sinceEpoch() !=
                        right.sinceEpoch()
                    );
                }

                inline
                bool
                operator <(
                    const Timestamp& left,
                    const Timestamp& right)
                {
                    return (
                        left.sinceEpoch() <
                        right.sinceEpoch()
                    );
                }

                inline
                bool
                operator <=(
                    const Timestamp& left,
                    const Timestamp& right)
                {
                    return (
                        left.sinceEpoch() <=
                        right.sinceEpoch()
                    );
                }

                inline
                bool
                operator >(
                    const Timestamp& left,
                    const Timestamp& right)
                {
                    return (
                        left.sinceEpoch() >
                        right.sinceEpoch()
                    );
                }

                inline
                bool
                operator >=(
                    const Timestamp& left,
                    const Timestamp& right)
                {
                    return (
                        left.sinceEpoch() >=
                        right.sinceEpoch()
                    );
                }

                inline
                Timestamp
                operator +(
                    const Timestamp& timestamp,
                    const TimeSpan& timeSpan)
                {
                    return
                        Timestamp(
                            timestamp.sinceEpoch() +
                            timeSpan.ticks()
                        );
                }

                inline
                Timestamp
                operator -(
                    const Timestamp& timestamp,
                    const TimeSpan& timeSpan)
                {
                    return
                        Timestamp(
                            timestamp.sinceEpoch() -
                            timeSpan.ticks()
                        );
                }

                inline
                TimeSpan
                operator -(
                    const Timestamp& left,
                    const Timestamp& right)
                {
                    return
                        TimeSpan(
                            left.sinceEpoch() -
                            right.sinceEpoch()
                        );
                }
 
                // Serialization.

                ONIXS_CBOE_CFE_BOE_API
                void
                toStrAsYYYYMMDD
                    (
                        std::string&,
                        Timestamp
                    );

                ONIXS_CBOE_CFE_BOE_API
                void
                toStrAsYYYYMMDDHHMMSS
                    (
                        std::string&,
                        Timestamp
                    );

                ONIXS_CBOE_CFE_BOE_API
                void
                toStrAsYYYYMMDDHHMMSSmsec
                    (
                        std::string&,
                        Timestamp
                    );

                ONIXS_CBOE_CFE_BOE_API
                void
                toStrAsYYYYMMDDHHMMSSnsec
                    (
                        std::string&,
                        Timestamp
                    );

                struct TimestampFormat
                {
                    enum Enum
                    {
                        YYYYMMDD,

                            YYYYMMDDHHMMSS,

                            YYYYMMDDHHMMSSmsec,

                            YYYYMMDDHHMMSSnsec
                    };
                };

                ONIXS_CBOE_CFE_BOE_API
                void
                toStr(
                    std::string& str,
                    Timestamp timestamp,
                    TimestampFormat::Enum format =
                    TimestampFormat::YYYYMMDDHHMMSSnsec);

                inline
                std::string
                toStr(
                    Timestamp timestamp,
                    TimestampFormat::Enum format =
                    TimestampFormat::YYYYMMDDHHMMSSnsec)
                {
                    std::string str;
 
                    toStr(str, timestamp, format);
 
                    return str;
                }

                ONIXS_CBOE_CFE_BOE_API
                bool
                fromStr(
                    Timestamp&,
                    const char*,
                    size_t);
 
                inline
                bool
                fromStr(
                    Timestamp& ts,
                    const std::string& str)
                {
                    return
                        fromStr(
                            ts, str.c_str(), str.size());
                }
 
 
 
 
            }
        }
    }
}