Timestamp.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 <ostream>
 
#include <OnixS/Eurex/MarketData/Compiler.h>
#include <OnixS/Eurex/MarketData/Numeric.h>
#include <OnixS/Eurex/MarketData/TimeSpan.h>
 
namespace OnixS
{
    namespace Eurex
    {
        namespace MarketData
        {
            struct TimeTraits
            {
                constexpr
                static Int64 nanosecondsPerDay()
                {
                    return 86400000000000ll;
                }

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

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

                constexpr
                static Int32 nanosecondsPerSecond()
                {
                    return 1000000000;
                }

                constexpr
                static Int32 nanosecondsPerMillisecond()
                {
                    return 1000000;
                }

                constexpr
                static Int32 nanosecondsPerMicrosecond()
                {
                    return 1000;
                }

                constexpr
                static Int32 hoursPerDay()
                {
                    return 24;
                }

                constexpr
                static Int32 minutesPerHour()
                {
                    return 60;
                }

                constexpr
                static Int32 secondsPerMinute()
                {
                    return 60;
                }

                constexpr
                static Int32 millisecondsPerSecond()
                {
                    return 1000;
                }

                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) noexcept
                    : ticks_(ticks)
                {
                }

                constexpr TimeSpan(Days days, Hours hours, Minutes minutes, Seconds seconds, Nanoseconds nanoseconds) noexcept
                    : 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)
                {
                }

                constexpr TimeSpan(Hours hours, Minutes minutes, Seconds seconds, Nanoseconds nanoseconds) noexcept
                    : 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)
                noexcept
                {
                    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_EUREX_EMDI_API
            void toStrAsHHMMSS(std::string&, TimeSpan);
 
            // Serializes timespan according to HH:MM:SS.sss pattern.
            ONIXS_EUREX_EMDI_API
            void  toStrAsHHMMSSmsec(std::string&, TimeSpan);
 
            // Serializes timespan according to D.HH:MM:SS.sssssssss pattern.
            ONIXS_EUREX_EMDI_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
                };
            };

            struct TimestampFormat
            {
                enum Enum
                {
                    YYYYMMDD,

                    YYYYMMDDHHMMSS,

                    YYYYMMDDHHMMSSMsec,

                    YYYYMMDDHHMMSSNsec
                };
            };

            class Timestamp
            {
            public:
                typedef UInt64 Ticks;

                typedef UInt32 Year;

                typedef  OnixS::Eurex::MarketData::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_EUREX_EMDI_API
                static Timestamp utcNow();

                ONIXS_EUREX_EMDI_API
                static  Timestamp now();

                explicit
                Timestamp(Ticks ticks = 0) noexcept
                    : 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) noexcept
                    : 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 noexcept
                {
                    return static_cast<Hour>(time().hours());
                }

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

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

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

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

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

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

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

                Ticks sinceEpoch() const noexcept
                {
                    return sinceEpoch_;
                }

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

                void
                swap(
                        Timestamp& other)
                {
                    std::swap(
                            sinceEpoch_,
                            other.sinceEpoch_);
                }

                static
                ONIXS_EUREX_EMDI_API
                Timestamp parse (unsigned long long presentation,
                        TimestampFormat::Enum format = TimestampFormat::YYYYMMDD);

                std::string toString(TimestampFormat::Enum format = TimestampFormat::YYYYMMDDHHMMSSNsec);
 
            private:
                // Time interval in nanoseconds since the 01-01-1970.
                Ticks sinceEpoch_;
 
                // Converts structured date-time into ticks.
                ONIXS_EUREX_EMDI_API
                static Ticks toTicks(Year, Month, Day, Hour, Minute, Second,Nanosecond);
 
                // Extracts date components from ticks.
                ONIXS_EUREX_EMDI_API
                static void toDate(Ticks, Year&, Month&, Day&);
            };

            inline
            Timestamp fromSeconds(UInt32 secondsSinceEpoch)
            {
                return Timestamp(
                        static_cast<Timestamp::Ticks>(
                                secondsSinceEpoch) * TimeTraits::nanosecondsPerSecond());
            }

            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_EUREX_EMDI_API
            void toStrAsYYYYMMDD
            (
                std::string&,
                Timestamp
            );

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

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

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

            ONIXS_EUREX_EMDI_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_EUREX_EMDI_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());
            }
 
            inline std::string Timestamp::toString(TimestampFormat::Enum format)
            {
                return toStr(*this, format);
            }
 
            inline std::ostream& operator<<(std::ostream& o, Timestamp ts)
            {
                o << ts.toString();
                return o;
            }
        }
    }
}