Time.h

Go to the documentation of this file.

/*
 * Copyright (c) Onix Solutions Limited. All rights reserved.
 *
 * This software owned by Onix Solutions Limited 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 "Export.h"
 
#include <iosfwd>
#include <string>
 
namespace OnixS { namespace ICE { namespace iMpact { namespace MarketData {

struct ONIXS_ICEMDH_EXPORT TimeSpanFormats
{
    enum Enum
    {
        HHMMSS,

        HHMMSSmsec,

        SDHHMMSSnsec
    };
};

typedef TimeSpanFormats::Enum TimeSpanFormat;

class ONIXS_ICEMDH_EXPORT TimeSpan
{
public:
    TimeSpan();

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

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

    TimeSpan(long long totalSeconds, int nanoseconds);

    TimeSpan(const TimeSpan& other);

    long long totalSeconds() const;

    int days() const;

    int hours() const;

    int minutes() const;

    int seconds() const;

    int milliseconds() const;

    int microseconds() const;

    int 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 TimeSpan deserialize(unsigned long long presentation, TimeSpanFormat format);

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

ONIXS_ICEMDH_EXPORT std::ostream& operator<<(std::ostream&, const TimeSpan&);

struct ONIXS_ICEMDH_EXPORT Months
{
    enum Enum
    {
        Undefined,
 
        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_ICEMDH_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;

class ONIXS_ICEMDH_EXPORT YearMonth
{
public:
    YearMonth();

    YearMonth(unsigned int year, Month month);

    YearMonth(const YearMonth& other);

    unsigned int year() const;

    Month month() const;

    bool operator==(const YearMonth&) const;

    bool operator!=(const YearMonth&) 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(unsigned long long);
 
protected:
    struct NoVerify
    {
    };

    YearMonth(unsigned int, Month, const NoVerify&);
 
private:
    unsigned int year_;
    Month month_;
};
 
inline unsigned int YearMonth::year() const
{
    return year_;
}
 
inline Month YearMonth::month() const
{
    return month_;
}
 
inline std::string YearMonth::toString() const
{
    std::string str;
 
    toString(str);
 
    return str;
}

ONIXS_ICEMDH_EXPORT std::ostream& operator<<(std::ostream&, const YearMonth&);

class ONIXS_ICEMDH_EXPORT Date : public YearMonth
{
public:
    Date();

    Date(unsigned int year, Month month, unsigned int day);

    Date(const Date& other);

    unsigned int day() const;

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

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

    bool operator<(const Date& other) const;

    bool operator>(const Date& other) const;

    Date& operator+=(TimeSpan& span);

    Date& operator-=(TimeSpan& span);

    Date& operator=(const Date& other);

    std::string toString() const;

    void toString(std::string&) const;

    static Date deserialize(unsigned long long);
 
private:
    unsigned int day_;

    Date(unsigned int year, Month month, unsigned int day, const NoVerify&);
};
 
inline unsigned int Date::day() const
{
    return day_;
}
 
inline std::string Date::toString() const
{
    std::string str;
 
    toString(str);
 
    return str;
}

ONIXS_ICEMDH_EXPORT TimeSpan operator-(const Date& left, const Date& right);

ONIXS_ICEMDH_EXPORT std::ostream& operator<<(std::ostream&, const Date&);

struct ONIXS_ICEMDH_EXPORT TimestampFormats
{
    enum Enum
    {
        YYYYMMDDHHMMSS,

        YYYYMMDDHHMMSSmsec,

        YYYYMMDDHHMMSSnsec
    };
};

typedef TimestampFormats::Enum TimestampFormat;

class ONIXS_ICEMDH_EXPORT Timestamp
{
public:
    Timestamp();

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

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

    Timestamp(const Timestamp& other);

    Timestamp(const TimeSpan&);

    unsigned int year() const;

    Month month() const;

    unsigned int day() const;

    unsigned int hour() const;

    unsigned int minute() const;

    unsigned int second() const;

    unsigned int millisecond() const;

    unsigned int microsecond() const;

    unsigned int nanosecond() const;

    Timestamp date() const;

    void date(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 Timestamp utcNow();

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

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

    static Timestamp deserialize(const std::string&);

    static Timestamp deserialize(unsigned long long presentation, TimestampFormat format);
 
private:
    friend ONIXS_ICEMDH_EXPORT TimeSpan operator-(const Timestamp& left, const Timestamp& right);

    TimeSpan sinceEpoch_;
};
 
inline unsigned int Timestamp::hour() const
{
    return static_cast<unsigned int>(sinceEpoch_.hours());
}
 
inline unsigned int Timestamp::minute() const
{
    return static_cast<unsigned int>(sinceEpoch_.minutes());
}
 
inline unsigned int Timestamp::second() const
{
    return static_cast<unsigned int>(sinceEpoch_.seconds());
}
 
inline unsigned int Timestamp::millisecond() const
{
    return static_cast<unsigned int>(sinceEpoch_.milliseconds());
}
 
inline unsigned int Timestamp::microsecond() const
{
    return static_cast<unsigned int>(sinceEpoch_.microseconds());
}
 
inline unsigned int Timestamp::nanosecond() const
{
    return static_cast<unsigned int>(sinceEpoch_.nanoseconds());
}
 
inline std::string Timestamp::toString(TimestampFormat format) const
{
    std::string str;
 
    toString(str, format);
 
    return str;
}

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

ONIXS_ICEMDH_EXPORT std::ostream& operator<<(std::ostream&, const Timestamp&);
 
}}}} // namespace OnixS::ICE::iMpact::MarketData