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 "OnixS/CME/DropCopy/Export.h"
#include "OnixS/CME/DropCopy/Numeric.h"
 
#include <string>
 
namespace OnixS { namespace CME { namespace DropCopy {

struct ONIXS_CME_DROP_COPY_EXPORT TimeSpanFormats
{
    enum Enum
    {
        HHMMSS,

        HHMMSSmsec,

        SDHHMMSSnsec
    };
};

typedef TimeSpanFormats::Enum TimeSpanFormat;

struct ONIXS_CME_DROP_COPY_EXPORT Subseconds
{
    enum Enum
    {
        Milli,

        Micro,

        Nano
    };
};

typedef Subseconds::Enum Subsecond;

class ONIXS_CME_DROP_COPY_EXPORT TimeSpan
{
public:
    TimeSpan();

    TimeSpan(Int32 hours, Int32 minutes, Int32 seconds, Int32 nanoseconds = 0);

    TimeSpan(Int32 days, Int32 hours, Int32 minutes, Int32 seconds, Int32 nanoseconds);

    TimeSpan(Int64 totalSeconds, Int32 nanoseconds);

    TimeSpan(const TimeSpan& other);

    Int64 totalSeconds() const;

    Int64 totalSubseconds(Subsecond subsecondType) const;

    Int32 days() const;

    Int32 hours() const;

    Int32 minutes() const;

    Int32 seconds() const;

    Int32 milliseconds() const;

    Int32 microseconds() const;

    Int32 nanoseconds() const;

    bool operator==(const TimeSpan& other) const;

    bool operator!=(const TimeSpan& other) const;

    bool operator<(const TimeSpan& other) const;

    bool operator>(const TimeSpan& other) const;

    TimeSpan& operator+=(const TimeSpan& other);

    TimeSpan& operator-=(const TimeSpan& other);

    TimeSpan& operator=(const TimeSpan& other);

    void toString(std::string& str, TimeSpanFormat format = TimeSpanFormats::SDHHMMSSnsec) const;

    std::string toString(TimeSpanFormat format = TimeSpanFormats::SDHHMMSSnsec) const;

    static TimeSpan deserialize(const std::string& str);

    static const TimeSpan Zero;
 
private:
    Int64 seconds_;
    Int32 nanoseconds_;
};
 
inline Int64 TimeSpan::totalSeconds() const
{
    return seconds_;
}
 
inline Int32 TimeSpan::nanoseconds() const
{
    return nanoseconds_;
}
 
inline std::string TimeSpan::toString(TimeSpanFormat format) const
{
    std::string str;
    toString(str, format);
    return str;
}

struct ONIXS_CME_DROP_COPY_EXPORT Months
{
    enum Enum
    {
        Bad,
 
        January,
        February,
        March,
        April,
        May,
        June,
        July,
        August,
        September,
        October,
        November,
        December,
 
        Count = December
    };

    static Enum deserialize(const char*);

    static const char* toString(Enum);
};

typedef Months::Enum Month;

struct ONIXS_CME_DROP_COPY_EXPORT DaysOfWeek
{
    enum Enum
    {
        Sunday,
        Monday,
        Tuesday,
        Wednesday,
        Thursday,
        Friday,
        Saturday,
 
        Total
    };

    static Enum deserialize(const char*);

    static const char* toString(Enum);
};

typedef DaysOfWeek::Enum DayOfWeek;

struct ONIXS_CME_DROP_COPY_EXPORT WeekCodes
{
    enum Enum
    {
        Invalid,
        Week1,
        Week2,
        Week3,
        Week4,
        Week5,
 
        LastWeek = Week5
    };

    static Enum deserialize(const char*);

    static const char* toString(Enum);
};

typedef WeekCodes::Enum WeekCode;

class ONIXS_CME_DROP_COPY_EXPORT YearMonth
{
public:
    YearMonth();

    YearMonth(UInt32 year, Month month);

    YearMonth(UInt32 year, Month month, UInt32 day);

    YearMonth(UInt32 year, Month month, WeekCode week);

    YearMonth(const YearMonth& other);

    UInt32 year() const
    {
        return year_;
    }

    Month month() const
    {
        return month_;
    }

    UInt32 day() const
    {
        return day_;
    }

    WeekCode week() const
    {
        return week_;
    }

    bool hasDay() const
    {
        return day_ != 0;
    }

    bool hasWeek() const
    {
        return week_ != WeekCodes::Invalid;
    }

    bool operator==(const YearMonth&) const;

    bool operator!=(const YearMonth&) const;

    bool operator<(const YearMonth& other) const;

    bool operator>(const YearMonth& other) const;
 
    // Re-initializes instance as copy of other one.
    YearMonth& operator=(const YearMonth& other);

    std::string toString() const;

    void toString(std::string&) const;

    static YearMonth deserialize(const StringRef&);
 
private:
    // Year component.
    UInt32 year_;
 
    // Month component.
    Month month_;
 
    // Day component.
    UInt32 day_;
 
    // Week component.
    WeekCode week_;
};
 
inline std::string YearMonth::toString() const
{
    std::string str;
    toString(str);
    return str;
}

struct ONIXS_CME_DROP_COPY_EXPORT TimestampFormats
{
    enum Enum
    {
        YYYYMMDD,

        YYYYMMDDHHMMSS,

        YYYYMMDDHHMMSSmsec,

        YYYYMMDDHHMMSSnsec
    };
};

typedef TimestampFormats::Enum TimestampFormat;

struct ONIXS_CME_DROP_COPY_EXPORT SinceEpochUnits
{
    enum Enum
    {
        Nanoseconds,
        Days
    };
};

typedef SinceEpochUnits::Enum SinceEpochUnit;

class ONIXS_CME_DROP_COPY_EXPORT Timestamp
{
public:
    Timestamp();

    Timestamp(UInt32 year, Month month, UInt32 day);

    Timestamp(
        UInt32 year,
        Month month,
        UInt32 day,
        UInt32 hour,
        UInt32 minute,
        UInt32 second,
        UInt32 nanosecond
    );

    Timestamp(const Timestamp& other);

    UInt32 year() const;

    Month month() const;

    UInt32 day() const;

    UInt32 hour() const;

    UInt32 minute() const;

    UInt32 second() const;

    UInt32 millisecond() const;

    UInt32 microsecond() const;

    UInt32 nanosecond() const;

    Timestamp date() const;

    TimeSpan time() const;

    DayOfWeek dayOfWeek() const;

    bool operator==(const Timestamp& other) const;

    bool operator!=(const Timestamp& other) const;

    bool operator<(const Timestamp& other) const;

    bool operator>(const Timestamp& other) const;

    Timestamp& operator+=(const TimeSpan& span);

    Timestamp& operator-=(const TimeSpan& span);

    Timestamp& operator=(const Timestamp& other);

    static Timestamp now();

    static void now(Timestamp&);

    static Timestamp utcNow();

    static void utcNow(Timestamp&);

    std::string toString(TimestampFormat format = TimestampFormats::YYYYMMDDHHMMSSnsec) const;

    void
    toString(std::string& str, TimestampFormat format = TimestampFormats::YYYYMMDDHHMMSSnsec) const;

    static Timestamp deserialize(const StringRef&);

    static Timestamp fromUnixTimestamp(UInt64 sinceEpoch, SinceEpochUnit unit);

    UInt64 toUnixTimestamp(SinceEpochUnit unit) const;

    static Timestamp maxTimestamp();
 
private:
    friend ONIXS_CME_DROP_COPY_EXPORT TimeSpan
    operator-(const Timestamp& left, const Timestamp& right);

    Timestamp(UInt64);

    UInt64 sinceEpoch_;
};
 
inline std::string Timestamp::toString(TimestampFormat format) const
{
    std::string str;
    toString(str, format);
    return str;
}

ONIXS_CME_DROP_COPY_EXPORT TimeSpan operator-(const Timestamp& left, const Timestamp& right);
 
}}}