blpapi_datetime.h

Go to the documentation of this file.

/* Copyright 2012. Bloomberg Finance L.P.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
 * deal in the Software without restriction, including without limitation the
 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
 * sell copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:  The above
 * copyright notice and this permission notice shall be included in all copies
 * or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 * IN THE SOFTWARE.
 */

 
#ifndef INCLUDED_BLPAPI_DATETIME
#define INCLUDED_BLPAPI_DATETIME
 
#include <blpapi_call.h>
#include <blpapi_defs.h>
#include <blpapi_exception.h>
#include <blpapi_streamproxy.h>
#include <blpapi_timepoint.h>
#include <blpapi_types.h>
 
#ifdef __cplusplus
extern "C" {
#endif



struct blpapi_Datetime_tag {
    blpapi_UChar_t parts; 
    blpapi_UChar_t hours; 
    blpapi_UChar_t minutes; 
    blpapi_UChar_t seconds; 
    blpapi_UInt16_t milliSeconds; 
    blpapi_UChar_t month; 
    blpapi_UChar_t day; 
    blpapi_UInt16_t year; 
    blpapi_Int16_t offset; 
};

struct blpapi_HighPrecisionDatetime_tag {
    blpapi_Datetime_t datetime; 
    blpapi_UInt32_t picoseconds; 
};

typedef struct blpapi_HighPrecisionDatetime_tag blpapi_HighPrecisionDatetime_t;

BLPAPI_EXPORT
int blpapi_Datetime_compare(blpapi_Datetime_t lhs, blpapi_Datetime_t rhs);

BLPAPI_EXPORT
int blpapi_Datetime_print(const blpapi_Datetime_t *datetime,
        blpapi_StreamWriter_t streamWriter,
        void *stream,
        int level,
        int spacesPerLevel);

BLPAPI_EXPORT
int blpapi_HighPrecisionDatetime_compare(
        const blpapi_HighPrecisionDatetime_t *lhs,
        const blpapi_HighPrecisionDatetime_t *rhs);

BLPAPI_EXPORT
int blpapi_HighPrecisionDatetime_print(
        const blpapi_HighPrecisionDatetime_t *datetime,
        blpapi_StreamWriter_t streamWriter,
        void *stream,
        int level,
        int spacesPerLevel);

BLPAPI_EXPORT
int blpapi_HighPrecisionDatetime_fromTimePoint(
        blpapi_HighPrecisionDatetime_t *datetime,
        const blpapi_TimePoint_t *timePoint,
        short offset);

 
#ifdef __cplusplus
} // extern "C"
 
#include <cassert>
#include <cstring> // for std::memset
#include <iosfwd>
 
namespace BloombergLP {
namespace blpapi {

struct DatetimeParts {

    enum Value {
 
        YEAR = BLPAPI_DATETIME_YEAR_PART, 
        MONTH = BLPAPI_DATETIME_MONTH_PART, 
        DAY = BLPAPI_DATETIME_DAY_PART, 
        OFFSET = BLPAPI_DATETIME_OFFSET_PART, 
        HOURS = BLPAPI_DATETIME_HOURS_PART, 
        MINUTES = BLPAPI_DATETIME_MINUTES_PART, 
        SECONDS = BLPAPI_DATETIME_SECONDS_PART, 
        FRACSECONDS = BLPAPI_DATETIME_FRACSECONDS_PART,
 
        MILLISECONDS = BLPAPI_DATETIME_MILLISECONDS_PART,
 
        DATE = BLPAPI_DATETIME_DATE_PART,
 
        TIME = BLPAPI_DATETIME_TIME_PART,
 
        TIMEFRACSECONDS = BLPAPI_DATETIME_TIMEFRACSECONDS_PART,
 
        TIMEMILLI = BLPAPI_DATETIME_TIMEMILLI_PART,
    };
};

class Datetime {
 
    blpapi_HighPrecisionDatetime_t d_value;
 
    static bool isLeapYear(int year);
 
    struct TimeTag { };
    Datetime(unsigned hours, unsigned minutes, unsigned seconds, TimeTag);
 
  public:
    typedef blpapi_HighPrecisionDatetime_t HighPrecision;
    struct Milliseconds {
        int d_msec;
        explicit Milliseconds(int milliseconds);
    };
    struct Microseconds {
        int d_usec;
        explicit Microseconds(int microseconds);
    };
    struct Nanoseconds {
        int d_nsec;
        explicit Nanoseconds(int nanoseconds);
    };
    struct Picoseconds {
        long long d_psec;
        explicit Picoseconds(long long picoseconds);
    };
    struct Offset {
        short d_minutesAheadOfUTC;
        explicit Offset(short minutesAheadOfUTC);
    };
 
    static bool isValidDate(int year, int month, int day);
 
    static bool isValidTime(int hours, int minutes, int seconds);
    static bool isValidTime(
            int hours, int minutes, int seconds, int milliSeconds);
    static bool isValidTime(int hours,
            int minutes,
            int seconds,
            Milliseconds fractionOfSecond);
    static bool isValidTime(int hours,
            int minutes,
            int seconds,
            Microseconds fractionOfSecond);
    static bool isValidTime(
            int hours, int minutes, int seconds, Nanoseconds fractionOfSecond);
    static bool isValidTime(
            int hours, int minutes, int seconds, Picoseconds fractionOfSecond);
 
    static Datetime createDatetime(unsigned year,
            unsigned month,
            unsigned day,
            unsigned hours,
            unsigned minutes,
            unsigned seconds);
 
    static Datetime createDatetime(unsigned year,
            unsigned month,
            unsigned day,
            unsigned hours,
            unsigned minutes,
            unsigned seconds,
            Offset offset);
 
    static Datetime createDatetime(unsigned year,
            unsigned month,
            unsigned day,
            unsigned hours,
            unsigned minutes,
            unsigned seconds,
            Milliseconds fractionOfSecond);
    static Datetime createDatetime(unsigned year,
            unsigned month,
            unsigned day,
            unsigned hours,
            unsigned minutes,
            unsigned seconds,
            Microseconds fractionOfSecond);
    static Datetime createDatetime(unsigned year,
            unsigned month,
            unsigned day,
            unsigned hours,
            unsigned minutes,
            unsigned seconds,
            Nanoseconds fractionOfSecond);
    static Datetime createDatetime(unsigned year,
            unsigned month,
            unsigned day,
            unsigned hours,
            unsigned minutes,
            unsigned seconds,
            Picoseconds fractionOfSecond);
 
    static Datetime createDatetime(unsigned year,
            unsigned month,
            unsigned day,
            unsigned hours,
            unsigned minutes,
            unsigned seconds,
            Milliseconds fractionOfSecond,
            Offset offset);
    static Datetime createDatetime(unsigned year,
            unsigned month,
            unsigned day,
            unsigned hours,
            unsigned minutes,
            unsigned seconds,
            Microseconds fractionOfSecond,
            Offset offset);
    static Datetime createDatetime(unsigned year,
            unsigned month,
            unsigned day,
            unsigned hours,
            unsigned minutes,
            unsigned seconds,
            Nanoseconds fractionOfSecond,
            Offset offset);
    static Datetime createDatetime(unsigned year,
            unsigned month,
            unsigned day,
            unsigned hours,
            unsigned minutes,
            unsigned seconds,
            Picoseconds fractionOfSecond,
            Offset offset);
 
    static Datetime createDate(unsigned year, unsigned month, unsigned day);
 
    static Datetime createTime(
            unsigned hours, unsigned minutes, unsigned seconds);
 
    static Datetime createTime(
            unsigned hours, unsigned minutes, unsigned seconds, Offset offset);
 
    static Datetime createTime(unsigned hours,
            unsigned minutes,
            unsigned seconds,
            unsigned milliseconds);
 
    static Datetime createTime(unsigned hours,
            unsigned minutes,
            unsigned seconds,
            unsigned milliseconds,
            Offset offset);
 
    static Datetime createTime(unsigned hours,
            unsigned minutes,
            unsigned seconds,
            Milliseconds fractionOfSecond);
    static Datetime createTime(unsigned hours,
            unsigned minutes,
            unsigned seconds,
            Microseconds fractionOfSecond);
    static Datetime createTime(unsigned hours,
            unsigned minutes,
            unsigned seconds,
            Nanoseconds fractionOfSecond);
    static Datetime createTime(unsigned hours,
            unsigned minutes,
            unsigned seconds,
            Picoseconds fractionOfSecond);
 
    static Datetime createTime(unsigned hours,
            unsigned minutes,
            unsigned seconds,
            Milliseconds fractionOfSecond,
            Offset offset);
    static Datetime createTime(unsigned hours,
            unsigned minutes,
            unsigned seconds,
            Microseconds fractionOfSecond,
            Offset offset);
    static Datetime createTime(unsigned hours,
            unsigned minutes,
            unsigned seconds,
            Nanoseconds fractionOfSecond,
            Offset offset);
    static Datetime createTime(unsigned hours,
            unsigned minutes,
            unsigned seconds,
            Picoseconds fractionOfSecond,
            Offset offset);
 
    Datetime();
 
    Datetime(const Datetime& original);
 
    explicit Datetime(const blpapi_Datetime_t& rawValue);
 
    explicit Datetime(const blpapi_HighPrecisionDatetime_t& rawValue);
 
    Datetime(unsigned year,
            unsigned month,
            unsigned day,
            unsigned hours,
            unsigned minutes,
            unsigned seconds);
 
    Datetime(unsigned year,
            unsigned month,
            unsigned day,
            unsigned hours,
            unsigned minutes,
            unsigned seconds,
            unsigned milliseconds);
 
    Datetime(unsigned year,
            unsigned month,
            unsigned day,
            unsigned hours,
            unsigned minutes,
            unsigned seconds,
            Milliseconds fractionOfSecond);
    Datetime(unsigned year,
            unsigned month,
            unsigned day,
            unsigned hours,
            unsigned minutes,
            unsigned seconds,
            Microseconds fractionOfSecond);
    Datetime(unsigned year,
            unsigned month,
            unsigned day,
            unsigned hours,
            unsigned minutes,
            unsigned seconds,
            Nanoseconds fractionOfSecond);
    Datetime(unsigned year,
            unsigned month,
            unsigned day,
            unsigned hours,
            unsigned minutes,
            unsigned seconds,
            Picoseconds fractionOfSecond);
 
    Datetime(unsigned year, unsigned month, unsigned day);
 
    Datetime(unsigned hours,
            unsigned minutes,
            unsigned seconds,
            unsigned milliseconds);
 
    Datetime(unsigned hours,
            unsigned minutes,
            unsigned seconds,
            Milliseconds fractionOfSecond);
    Datetime(unsigned hours,
            unsigned minutes,
            unsigned seconds,
            Microseconds fractionOfSecond);
    Datetime(unsigned hours,
            unsigned minutes,
            unsigned seconds,
            Nanoseconds fractionOfSecond);
    Datetime(unsigned hours,
            unsigned minutes,
            unsigned seconds,
            Picoseconds fractionOfSecond);
 
    Datetime& operator=(const Datetime& rhs);
 
    void setDate(unsigned year, unsigned month, unsigned day);
 
    void setTime(unsigned hours, unsigned minutes, unsigned seconds);
 
    void setTime(unsigned hours,
            unsigned minutes,
            unsigned seconds,
            unsigned milliseconds);
 
    void setTime(unsigned hours,
            unsigned minutes,
            unsigned seconds,
            Milliseconds fractionOfSecond);
    void setTime(unsigned hours,
            unsigned minutes,
            unsigned seconds,
            Microseconds fractionOfSecond);
    void setTime(unsigned hours,
            unsigned minutes,
            unsigned seconds,
            Nanoseconds fractionOfSecond);
    void setTime(unsigned hours,
            unsigned minutes,
            unsigned seconds,
            Picoseconds fractionOfSecond);
 
    void setOffset(short minutesAheadOfUTC);
 
    void setYear(unsigned value);
 
    void setMonth(unsigned value);
 
    void setDay(unsigned value);
 
    void setHours(unsigned value);
 
    void setMinutes(unsigned value);
 
    void setSeconds(unsigned value);
 
    void setMilliseconds(unsigned milliseconds);
 
    void setFractionOfSecond(Milliseconds value);
 
    void setFractionOfSecond(Microseconds value);
 
    void setFractionOfSecond(Nanoseconds value);
 
    void setFractionOfSecond(Picoseconds value);
 
    blpapi_Datetime_t& rawValue();
 
    blpapi_HighPrecisionDatetime_t& rawHighPrecisionValue();
 
    bool hasParts(unsigned parts) const;
 
    unsigned parts() const;
 
    unsigned year() const;
 
    unsigned month() const;
 
    unsigned day() const;
 
    unsigned hours() const;
 
    unsigned minutes() const;
 
    unsigned seconds() const;
 
    unsigned milliSeconds() const;
 
    unsigned milliseconds() const;
 
    unsigned microseconds() const;
 
    unsigned nanoseconds() const;
 
    unsigned long long picoseconds() const;
 
    short offset() const;
 
    const blpapi_Datetime_t& rawValue() const;
 
    const blpapi_HighPrecisionDatetime_t& rawHighPrecisionValue() const;
 
    const HighPrecision& highPrecisionValue() const;
 
    bool isValid() const;
 
    std::ostream& print(
            std::ostream& stream, int level = 0, int spacesPerLevel = 4) const;
};

struct DatetimeUtil {
 
    static Datetime fromTimePoint(const TimePoint& timePoint,
            Datetime::Offset offset = Datetime::Offset(0));
};

 
// ============================================================================
//                      INLINE FUNCTION DEFINITIONS
// ============================================================================
 
// --------------
// class Datetime
// --------------
 
// FREE OPERATORS
bool operator==(const Datetime& lhs, const Datetime& rhs);
 
bool operator!=(const Datetime& lhs, const Datetime& rhs);
 
bool operator<(const Datetime& lhs, const Datetime& rhs);
bool operator<=(const Datetime& lhs, const Datetime& rhs);
bool operator>(const Datetime& lhs, const Datetime& rhs);
bool operator>=(const Datetime& lhs, const Datetime& rhs);
 
std::ostream& operator<<(std::ostream& stream, const Datetime& datetime);
 
namespace util {

 
constexpr const char *to_string(DatetimeParts::Value part);

 
} // close namespace util
 
inline bool Datetime::isLeapYear(int y)
{
    return 0 == y % 4 && (y <= 1752 || 0 != y % 100 || 0 == y % 400);
}
 
inline Datetime::Datetime(
        unsigned newHours, unsigned newMinutes, unsigned newSeconds, TimeTag)
{
    std::memset(&d_value, 0, sizeof(d_value));
    setTime(newHours, newMinutes, newSeconds);
}
 
inline Datetime::Milliseconds::Milliseconds(int milliseconds)
    : d_msec(milliseconds)
{
}
 
inline Datetime::Microseconds::Microseconds(int microseconds)
    : d_usec(microseconds)
{
}
 
inline Datetime::Nanoseconds::Nanoseconds(int nanoseconds)
    : d_nsec(nanoseconds)
{
}
 
inline Datetime::Picoseconds::Picoseconds(long long picoseconds)
    : d_psec(picoseconds)
{
}
 
inline Datetime::Offset::Offset(short minutesAheadOfUTC)
    : d_minutesAheadOfUTC(minutesAheadOfUTC)
{
}
 
inline bool Datetime::isValidDate(int year, int month, int day)
{
    if ((year <= 0) || (year > 9999) || (month <= 0) || (month > 12)
            || (day <= 0) || (day > 31)) {
        return false;
    }
    if (year == 1752) {
        if (month == 9 && day > 2 && day < 14) {
            return false;
        }
    }
    if (day < 29) {
        return true;
    }
    switch (month) {
    case 1:
    case 3:
    case 5:
    case 7:
    case 8:
    case 10:
    case 12:
        return true;
 
    case 4:
    case 6:
    case 9:
    case 11: {
        if (day > 30) {
            return false;
        } else {
            return true;
        }
    }
    case 2: {
        if (isLeapYear(year)) {
            if (day > 29) {
                return false;
            } else {
                return true;
            }
        } else if (day > 28) {
            return false;
        } else {
            return true;
        }
    }
    default: {
        return true;
    }
    }
}
 
inline bool Datetime::isValidTime(int hours, int minutes, int seconds)
{
    return (hours >= 0) && (hours < 24) && (minutes >= 0) && (minutes < 60)
            && (seconds >= 0) && (seconds < 60);
}
 
inline bool Datetime::isValidTime(
        int hours, int minutes, int seconds, int milliSeconds)
{
    return (hours >= 0) && (hours < 24) && (minutes >= 0) && (minutes < 60)
            && (seconds >= 0) && (seconds < 60) && (milliSeconds >= 0)
            && (milliSeconds < 1000);
}
 
inline bool Datetime::isValidTime(
        int hours, int minutes, int seconds, Milliseconds fractionOfSecond)
{
    return isValidTime(hours, minutes, seconds, fractionOfSecond.d_msec);
}
 
inline bool Datetime::isValidTime(
        int hours, int minutes, int seconds, Microseconds fractionOfSecond)
{
    return (hours >= 0) && (hours < 24) && (minutes >= 0) && (minutes < 60)
            && (seconds >= 0) && (seconds < 60)
            && (fractionOfSecond.d_usec >= 0)
            && (fractionOfSecond.d_usec < 1000 * 1000);
}
 
inline bool Datetime::isValidTime(
        int hours, int minutes, int seconds, Nanoseconds fractionOfSecond)
{
    return (hours >= 0) && (hours < 24) && (minutes >= 0) && (minutes < 60)
            && (seconds >= 0) && (seconds < 60)
            && (fractionOfSecond.d_nsec >= 0)
            && (fractionOfSecond.d_nsec < 1000 * 1000 * 1000);
}
 
inline bool Datetime::isValidTime(
        int hours, int minutes, int seconds, Picoseconds fractionOfSecond)
{
    return (hours >= 0) && (hours < 24) && (minutes >= 0) && (minutes < 60)
            && (seconds >= 0) && (seconds < 60)
            && (fractionOfSecond.d_psec >= 0)
            && (fractionOfSecond.d_psec < 1000LL * 1000 * 1000 * 1000);
}
 
inline Datetime Datetime::createDatetime(unsigned year,
        unsigned month,
        unsigned day,
        unsigned hours,
        unsigned minutes,
        unsigned seconds)
{
    return Datetime(year, month, day, hours, minutes, seconds);
}
 
inline Datetime Datetime::createDatetime(unsigned year,
        unsigned month,
        unsigned day,
        unsigned hours,
        unsigned minutes,
        unsigned seconds,
        Offset offset)
{
    Datetime dt(year, month, day, hours, minutes, seconds);
    dt.setOffset(offset.d_minutesAheadOfUTC);
    return dt;
}
 
inline Datetime Datetime::createDatetime(unsigned year,
        unsigned month,
        unsigned day,
        unsigned hours,
        unsigned minutes,
        unsigned seconds,
        Milliseconds fractionOfSecond)
{
    return Datetime(
            year, month, day, hours, minutes, seconds, fractionOfSecond);
}
 
inline Datetime Datetime::createDatetime(unsigned year,
        unsigned month,
        unsigned day,
        unsigned hours,
        unsigned minutes,
        unsigned seconds,
        Microseconds fractionOfSecond)
{
    return Datetime(
            year, month, day, hours, minutes, seconds, fractionOfSecond);
}
 
inline Datetime Datetime::createDatetime(unsigned year,
        unsigned month,
        unsigned day,
        unsigned hours,
        unsigned minutes,
        unsigned seconds,
        Nanoseconds fractionOfSecond)
{
    return Datetime(
            year, month, day, hours, minutes, seconds, fractionOfSecond);
}
 
inline Datetime Datetime::createDatetime(unsigned year,
        unsigned month,
        unsigned day,
        unsigned hours,
        unsigned minutes,
        unsigned seconds,
        Picoseconds fractionOfSecond)
{
    return Datetime(
            year, month, day, hours, minutes, seconds, fractionOfSecond);
}
 
inline Datetime Datetime::createDatetime(unsigned year,
        unsigned month,
        unsigned day,
        unsigned hours,
        unsigned minutes,
        unsigned seconds,
        Milliseconds fractionOfSecond,
        Offset offset)
{
    Datetime dt(year, month, day, hours, minutes, seconds, fractionOfSecond);
    dt.setOffset(offset.d_minutesAheadOfUTC);
    return dt;
}
 
inline Datetime Datetime::createDatetime(unsigned year,
        unsigned month,
        unsigned day,
        unsigned hours,
        unsigned minutes,
        unsigned seconds,
        Microseconds fractionOfSecond,
        Offset offset)
{
    Datetime dt(year, month, day, hours, minutes, seconds, fractionOfSecond);
    dt.setOffset(offset.d_minutesAheadOfUTC);
    return dt;
}
 
inline Datetime Datetime::createDatetime(unsigned year,
        unsigned month,
        unsigned day,
        unsigned hours,
        unsigned minutes,
        unsigned seconds,
        Nanoseconds fractionOfSecond,
        Offset offset)
{
    Datetime dt(year, month, day, hours, minutes, seconds, fractionOfSecond);
    dt.setOffset(offset.d_minutesAheadOfUTC);
    return dt;
}
 
inline Datetime Datetime::createDatetime(unsigned year,
        unsigned month,
        unsigned day,
        unsigned hours,
        unsigned minutes,
        unsigned seconds,
        Picoseconds fractionOfSecond,
        Offset offset)
{
    Datetime dt(year, month, day, hours, minutes, seconds, fractionOfSecond);
    dt.setOffset(offset.d_minutesAheadOfUTC);
    return dt;
}
 
inline Datetime Datetime::createDate(
        unsigned year, unsigned month, unsigned day)
{
    return Datetime(year, month, day);
}
 
inline Datetime Datetime::createTime(
        unsigned hours, unsigned minutes, unsigned seconds)
{
    return Datetime(hours, minutes, seconds, TimeTag());
}
 
inline Datetime Datetime::createTime(
        unsigned hours, unsigned minutes, unsigned seconds, Offset offset)
{
    Datetime dt(hours, minutes, seconds, TimeTag());
    dt.setOffset(offset.d_minutesAheadOfUTC);
    return dt;
}
 
inline Datetime Datetime::createTime(unsigned hours,
        unsigned minutes,
        unsigned seconds,
        unsigned milliseconds)
{
    return Datetime(hours, minutes, seconds, milliseconds);
}
 
inline
 
        Datetime
        Datetime::createTime(unsigned hours,
                unsigned minutes,
                unsigned seconds,
                unsigned milliseconds,
                Offset offset)
{
    Datetime dt(hours, minutes, seconds, milliseconds);
    dt.setOffset(offset.d_minutesAheadOfUTC);
    return dt;
}
 
inline Datetime Datetime::createTime(unsigned hours,
        unsigned minutes,
        unsigned seconds,
        Milliseconds fractionOfSecond)
{
    return Datetime(hours, minutes, seconds, fractionOfSecond);
}
 
inline Datetime Datetime::createTime(unsigned hours,
        unsigned minutes,
        unsigned seconds,
        Microseconds fractionOfSecond)
{
    return Datetime(hours, minutes, seconds, fractionOfSecond);
}
 
inline Datetime Datetime::createTime(unsigned hours,
        unsigned minutes,
        unsigned seconds,
        Nanoseconds fractionOfSecond)
{
    return Datetime(hours, minutes, seconds, fractionOfSecond);
}
 
inline Datetime Datetime::createTime(unsigned hours,
        unsigned minutes,
        unsigned seconds,
        Picoseconds fractionOfSecond)
{
    return Datetime(hours, minutes, seconds, fractionOfSecond);
}
 
inline Datetime Datetime::createTime(unsigned hours,
        unsigned minutes,
        unsigned seconds,
        Milliseconds fractionOfSecond,
        Offset offset)
{
    Datetime dt(hours, minutes, seconds, fractionOfSecond);
    dt.setOffset(offset.d_minutesAheadOfUTC);
    return dt;
}
 
inline Datetime Datetime::createTime(unsigned hours,
        unsigned minutes,
        unsigned seconds,
        Microseconds fractionOfSecond,
        Offset offset)
{
    Datetime dt(hours, minutes, seconds, fractionOfSecond);
    dt.setOffset(offset.d_minutesAheadOfUTC);
    return dt;
}
 
inline Datetime Datetime::createTime(unsigned hours,
        unsigned minutes,
        unsigned seconds,
        Nanoseconds fractionOfSecond,
        Offset offset)
{
    Datetime dt(hours, minutes, seconds, fractionOfSecond);
    dt.setOffset(offset.d_minutesAheadOfUTC);
    return dt;
}
 
inline Datetime Datetime::createTime(unsigned hours,
        unsigned minutes,
        unsigned seconds,
        Picoseconds fractionOfSecond,
        Offset offset)
{
    Datetime dt(hours, minutes, seconds, fractionOfSecond);
    dt.setOffset(offset.d_minutesAheadOfUTC);
    return dt;
}
 
inline Datetime::Datetime()
{
    std::memset(&d_value, 0, sizeof(d_value));
    d_value.datetime.year = 1;
    d_value.datetime.month = 1;
    d_value.datetime.day = 1;
}
 
inline Datetime::Datetime(const Datetime& original)
    : d_value(original.d_value)
{
}
 
inline Datetime::Datetime(const blpapi_Datetime_t& newRawValue)
{
    d_value.datetime = newRawValue;
    d_value.picoseconds = 0;
}
 
inline Datetime::Datetime(const blpapi_HighPrecisionDatetime_t& newRawValue)
    : d_value(newRawValue)
{
}
 
inline Datetime::Datetime(unsigned newYear,
        unsigned newMonth,
        unsigned newDay,
        unsigned newHours,
        unsigned newMinutes,
        unsigned newSeconds)
{
    d_value.datetime.offset = 0;
    d_value.datetime.year = static_cast<blpapi_UInt16_t>(newYear);
    d_value.datetime.month = static_cast<blpapi_UChar_t>(newMonth);
    d_value.datetime.day = static_cast<blpapi_UChar_t>(newDay);
    d_value.datetime.hours = static_cast<blpapi_UChar_t>(newHours);
    d_value.datetime.minutes = static_cast<blpapi_UChar_t>(newMinutes);
    d_value.datetime.seconds = static_cast<blpapi_UChar_t>(newSeconds);
    d_value.datetime.milliSeconds = 0;
    d_value.picoseconds = 0;
    d_value.datetime.parts = DatetimeParts::DATE | DatetimeParts::TIME;
}
 
inline Datetime::Datetime(unsigned newYear,
        unsigned newMonth,
        unsigned newDay,
        unsigned newHours,
        unsigned newMinutes,
        unsigned newSeconds,
        unsigned newMilliSeconds)
{
    d_value.datetime.offset = 0;
    d_value.datetime.year = static_cast<blpapi_UInt16_t>(newYear);
    d_value.datetime.month = static_cast<blpapi_UChar_t>(newMonth);
    d_value.datetime.day = static_cast<blpapi_UChar_t>(newDay);
    d_value.datetime.hours = static_cast<blpapi_UChar_t>(newHours);
    d_value.datetime.minutes = static_cast<blpapi_UChar_t>(newMinutes);
    d_value.datetime.seconds = static_cast<blpapi_UChar_t>(newSeconds);
    d_value.datetime.milliSeconds
            = static_cast<blpapi_UInt16_t>(newMilliSeconds);
    d_value.picoseconds = 0;
    d_value.datetime.parts
            = DatetimeParts::DATE | DatetimeParts::TIMEFRACSECONDS;
}
 
inline Datetime::Datetime(unsigned newYear,
        unsigned newMonth,
        unsigned newDay,
        unsigned newHours,
        unsigned newMinutes,
        unsigned newSeconds,
        Milliseconds fractionOfSecond)
{
    d_value.datetime.offset = 0;
    d_value.datetime.year = static_cast<blpapi_UInt16_t>(newYear);
    d_value.datetime.month = static_cast<blpapi_UChar_t>(newMonth);
    d_value.datetime.day = static_cast<blpapi_UChar_t>(newDay);
    d_value.datetime.hours = static_cast<blpapi_UChar_t>(newHours);
    d_value.datetime.minutes = static_cast<blpapi_UChar_t>(newMinutes);
    d_value.datetime.seconds = static_cast<blpapi_UChar_t>(newSeconds);
    d_value.datetime.milliSeconds
            = static_cast<blpapi_UInt16_t>(fractionOfSecond.d_msec);
    d_value.picoseconds = 0;
    d_value.datetime.parts
            = DatetimeParts::DATE | DatetimeParts::TIMEFRACSECONDS;
}
 
inline Datetime::Datetime(unsigned newYear,
        unsigned newMonth,
        unsigned newDay,
        unsigned newHours,
        unsigned newMinutes,
        unsigned newSeconds,
        Microseconds fractionOfSecond)
{
    d_value.datetime.offset = 0;
    d_value.datetime.year = static_cast<blpapi_UInt16_t>(newYear);
    d_value.datetime.month = static_cast<blpapi_UChar_t>(newMonth);
    d_value.datetime.day = static_cast<blpapi_UChar_t>(newDay);
    d_value.datetime.hours = static_cast<blpapi_UChar_t>(newHours);
    d_value.datetime.minutes = static_cast<blpapi_UChar_t>(newMinutes);
    d_value.datetime.seconds = static_cast<blpapi_UChar_t>(newSeconds);
    d_value.datetime.milliSeconds
            = static_cast<blpapi_UInt16_t>(fractionOfSecond.d_usec / 1000);
    d_value.picoseconds = static_cast<blpapi_UInt32_t>(
            (fractionOfSecond.d_usec % 1000) * 1000 * 1000);
    d_value.datetime.parts
            = DatetimeParts::DATE | DatetimeParts::TIMEFRACSECONDS;
}
 
inline Datetime::Datetime(unsigned newYear,
        unsigned newMonth,
        unsigned newDay,
        unsigned newHours,
        unsigned newMinutes,
        unsigned newSeconds,
        Nanoseconds fractionOfSecond)
{
    d_value.datetime.offset = 0;
    d_value.datetime.year = static_cast<blpapi_UInt16_t>(newYear);
    d_value.datetime.month = static_cast<blpapi_UChar_t>(newMonth);
    d_value.datetime.day = static_cast<blpapi_UChar_t>(newDay);
    d_value.datetime.hours = static_cast<blpapi_UChar_t>(newHours);
    d_value.datetime.minutes = static_cast<blpapi_UChar_t>(newMinutes);
    d_value.datetime.seconds = static_cast<blpapi_UChar_t>(newSeconds);
    d_value.datetime.milliSeconds = static_cast<blpapi_UInt16_t>(
            fractionOfSecond.d_nsec / 1000 / 1000);
    d_value.picoseconds = static_cast<blpapi_UInt32_t>(
            (fractionOfSecond.d_nsec % (1000 * 1000)) * 1000);
    d_value.datetime.parts
            = DatetimeParts::DATE | DatetimeParts::TIMEFRACSECONDS;
}
 
inline Datetime::Datetime(unsigned newYear,
        unsigned newMonth,
        unsigned newDay,
        unsigned newHours,
        unsigned newMinutes,
        unsigned newSeconds,
        Picoseconds fractionOfSecond)
{
    d_value.datetime.offset = 0;
    d_value.datetime.year = static_cast<blpapi_UInt16_t>(newYear);
    d_value.datetime.month = static_cast<blpapi_UChar_t>(newMonth);
    d_value.datetime.day = static_cast<blpapi_UChar_t>(newDay);
    d_value.datetime.hours = static_cast<blpapi_UChar_t>(newHours);
    d_value.datetime.minutes = static_cast<blpapi_UChar_t>(newMinutes);
    d_value.datetime.seconds = static_cast<blpapi_UChar_t>(newSeconds);
    d_value.datetime.milliSeconds = static_cast<blpapi_UInt16_t>(
            fractionOfSecond.d_psec / 1000 / 1000 / 1000);
    d_value.picoseconds = static_cast<blpapi_UInt32_t>(
            fractionOfSecond.d_psec % (1000 * 1000 * 1000));
    d_value.datetime.parts
            = DatetimeParts::DATE | DatetimeParts::TIMEFRACSECONDS;
}
 
inline Datetime::Datetime(unsigned newYear, unsigned newMonth, unsigned newDay)
{
    std::memset(&d_value, 0, sizeof(d_value));
    setDate(newYear, newMonth, newDay);
}
 
inline Datetime::Datetime(unsigned newHours,
        unsigned newMinutes,
        unsigned newSeconds,
        unsigned newMilliSeconds)
{
    std::memset(&d_value, 0, sizeof(d_value));
    setTime(newHours, newMinutes, newSeconds, newMilliSeconds);
}
 
inline Datetime::Datetime(unsigned newHours,
        unsigned newMinutes,
        unsigned newSeconds,
        Milliseconds fractionOfSecond)
{
    std::memset(&d_value, 0, sizeof(d_value));
    setTime(newHours, newMinutes, newSeconds, fractionOfSecond);
}
 
inline Datetime::Datetime(unsigned newHours,
        unsigned newMinutes,
        unsigned newSeconds,
        Microseconds fractionOfSecond)
{
    std::memset(&d_value, 0, sizeof(d_value));
    setTime(newHours, newMinutes, newSeconds, fractionOfSecond);
}
 
inline Datetime::Datetime(unsigned newHours,
        unsigned newMinutes,
        unsigned newSeconds,
        Nanoseconds fractionOfSecond)
{
    std::memset(&d_value, 0, sizeof(d_value));
    setTime(newHours, newMinutes, newSeconds, fractionOfSecond);
}
 
inline Datetime::Datetime(unsigned newHours,
        unsigned newMinutes,
        unsigned newSeconds,
        Picoseconds fractionOfSecond)
{
    std::memset(&d_value, 0, sizeof(d_value));
    setTime(newHours, newMinutes, newSeconds, fractionOfSecond);
}
 
inline Datetime& Datetime::operator=(const Datetime& rhs)
{
    d_value = rhs.d_value;
    return *this;
}
 
inline void Datetime::setDate(
        unsigned newYear, unsigned newMonth, unsigned newDay)
{
    d_value.datetime.day = static_cast<blpapi_UChar_t>(newDay);
    d_value.datetime.month = static_cast<blpapi_UChar_t>(newMonth);
    d_value.datetime.year = static_cast<blpapi_UInt16_t>(newYear);
    d_value.datetime.parts |= DatetimeParts::DATE;
}
 
inline void Datetime::setTime(
        unsigned newHours, unsigned newMinutes, unsigned newSeconds)
{
    d_value.datetime.hours = static_cast<blpapi_UChar_t>(newHours);
    d_value.datetime.minutes = static_cast<blpapi_UChar_t>(newMinutes);
    d_value.datetime.seconds = static_cast<blpapi_UChar_t>(newSeconds);
    d_value.datetime.milliSeconds = 0;
    d_value.picoseconds = 0;
    d_value.datetime.parts = static_cast<blpapi_UChar_t>(
            (d_value.datetime.parts & ~DatetimeParts::FRACSECONDS)
            | DatetimeParts::TIME);
}
 
inline void Datetime::setTime(unsigned newHours,
        unsigned newMinutes,
        unsigned newSeconds,
        unsigned newMilliSeconds)
{
    d_value.datetime.hours = static_cast<blpapi_UChar_t>(newHours);
    d_value.datetime.minutes = static_cast<blpapi_UChar_t>(newMinutes);
    d_value.datetime.seconds = static_cast<blpapi_UChar_t>(newSeconds);
    d_value.datetime.milliSeconds
            = static_cast<blpapi_UInt16_t>(newMilliSeconds);
    d_value.picoseconds = 0;
    d_value.datetime.parts |= DatetimeParts::TIMEFRACSECONDS;
}
 
inline void Datetime::setTime(unsigned newHours,
        unsigned newMinutes,
        unsigned newSeconds,
        Milliseconds fractionOfSecond)
{
    d_value.datetime.hours = static_cast<blpapi_UChar_t>(newHours);
    d_value.datetime.minutes = static_cast<blpapi_UChar_t>(newMinutes);
    d_value.datetime.seconds = static_cast<blpapi_UChar_t>(newSeconds);
    d_value.datetime.milliSeconds
            = static_cast<blpapi_UInt16_t>(fractionOfSecond.d_msec);
    d_value.picoseconds = 0;
    d_value.datetime.parts |= DatetimeParts::TIMEFRACSECONDS;
}
 
inline void Datetime::setTime(unsigned newHours,
        unsigned newMinutes,
        unsigned newSeconds,
        Microseconds fractionOfSecond)
{
    d_value.datetime.hours = static_cast<blpapi_UChar_t>(newHours);
    d_value.datetime.minutes = static_cast<blpapi_UChar_t>(newMinutes);
    d_value.datetime.seconds = static_cast<blpapi_UChar_t>(newSeconds);
    d_value.datetime.milliSeconds
            = static_cast<blpapi_UInt16_t>(fractionOfSecond.d_usec / 1000);
    d_value.picoseconds = static_cast<blpapi_UInt32_t>(
            fractionOfSecond.d_usec % 1000 * 1000 * 1000);
    d_value.datetime.parts |= DatetimeParts::TIMEFRACSECONDS;
}
 
inline void Datetime::setTime(unsigned newHours,
        unsigned newMinutes,
        unsigned newSeconds,
        Nanoseconds fractionOfSecond)
{
    d_value.datetime.hours = static_cast<blpapi_UChar_t>(newHours);
    d_value.datetime.minutes = static_cast<blpapi_UChar_t>(newMinutes);
    d_value.datetime.seconds = static_cast<blpapi_UChar_t>(newSeconds);
    d_value.datetime.milliSeconds = static_cast<blpapi_UInt16_t>(
            fractionOfSecond.d_nsec / 1000 / 1000);
    d_value.picoseconds = static_cast<blpapi_UInt32_t>(
            fractionOfSecond.d_nsec % (1000 * 1000) * 1000);
    d_value.datetime.parts |= DatetimeParts::TIMEFRACSECONDS;
}
 
inline void Datetime::setTime(unsigned newHours,
        unsigned newMinutes,
        unsigned newSeconds,
        Picoseconds fractionOfSecond)
{
    d_value.datetime.hours = static_cast<blpapi_UChar_t>(newHours);
    d_value.datetime.minutes = static_cast<blpapi_UChar_t>(newMinutes);
    d_value.datetime.seconds = static_cast<blpapi_UChar_t>(newSeconds);
    d_value.datetime.milliSeconds = static_cast<blpapi_UInt16_t>(
            fractionOfSecond.d_psec / 1000 / 1000 / 1000);
    d_value.picoseconds = static_cast<blpapi_UInt32_t>(
            fractionOfSecond.d_psec % (1000 * 1000 * 1000));
    d_value.datetime.parts |= DatetimeParts::TIMEFRACSECONDS;
}
 
inline void Datetime::setOffset(short value)
{
    d_value.datetime.offset = value;
    d_value.datetime.parts |= DatetimeParts::OFFSET;
}
 
inline void Datetime::setYear(unsigned value)
{
    d_value.datetime.year = static_cast<blpapi_UInt16_t>(value);
    d_value.datetime.parts |= DatetimeParts::YEAR;
}
 
inline void Datetime::setMonth(unsigned value)
{
    d_value.datetime.month = static_cast<blpapi_UChar_t>(value);
    d_value.datetime.parts |= DatetimeParts::MONTH;
}
 
inline void Datetime::setDay(unsigned value)
{
    d_value.datetime.day = static_cast<blpapi_UChar_t>(value);
    d_value.datetime.parts |= DatetimeParts::DAY;
}
 
inline void Datetime::setHours(unsigned value)
{
    d_value.datetime.hours = static_cast<blpapi_UChar_t>(value);
    d_value.datetime.parts |= DatetimeParts::HOURS;
}
 
inline void Datetime::setMinutes(unsigned value)
{
    d_value.datetime.minutes = static_cast<blpapi_UChar_t>(value);
    d_value.datetime.parts |= DatetimeParts::MINUTES;
}
 
inline void Datetime::setSeconds(unsigned value)
{
    d_value.datetime.seconds = static_cast<blpapi_UChar_t>(value);
    d_value.datetime.parts |= DatetimeParts::SECONDS;
}
 
inline void Datetime::setMilliseconds(unsigned value)
{
    d_value.datetime.milliSeconds = static_cast<blpapi_UInt16_t>(value);
    d_value.picoseconds = 0;
    d_value.datetime.parts |= DatetimeParts::FRACSECONDS;
}
 
inline void Datetime::setFractionOfSecond(Milliseconds value)
{
    d_value.datetime.milliSeconds = static_cast<blpapi_UInt16_t>(value.d_msec);
    d_value.picoseconds = 0;
    d_value.datetime.parts |= DatetimeParts::FRACSECONDS;
}
 
inline void Datetime::setFractionOfSecond(Microseconds value)
{
    d_value.datetime.milliSeconds
            = static_cast<blpapi_UInt16_t>(value.d_usec / 1000);
    d_value.picoseconds
            = static_cast<blpapi_UInt32_t>(value.d_usec % 1000 * 1000 * 1000);
    d_value.datetime.parts |= DatetimeParts::FRACSECONDS;
}
 
inline void Datetime::setFractionOfSecond(Nanoseconds value)
{
    d_value.datetime.milliSeconds
            = static_cast<blpapi_UInt16_t>(value.d_nsec / 1000 / 1000);
    d_value.picoseconds = static_cast<blpapi_UInt32_t>(
            value.d_nsec % (1000 * 1000) * 1000);
    d_value.datetime.parts |= DatetimeParts::FRACSECONDS;
}
 
inline void Datetime::setFractionOfSecond(Picoseconds value)
{
    d_value.datetime.milliSeconds
            = static_cast<blpapi_UInt16_t>(value.d_psec / 1000 / 1000 / 1000);
    d_value.picoseconds = static_cast<blpapi_UInt32_t>(
            value.d_psec % (1000 * 1000 * 1000));
    d_value.datetime.parts |= DatetimeParts::FRACSECONDS;
}
 
inline blpapi_Datetime_t& Datetime::rawValue() { return d_value.datetime; }
 
inline blpapi_HighPrecisionDatetime_t& Datetime::rawHighPrecisionValue()
{
    return d_value;
}
 
inline bool Datetime::hasParts(unsigned newParts) const
{
    return newParts == (d_value.datetime.parts & newParts);
}
 
inline unsigned Datetime::parts() const { return d_value.datetime.parts; }
 
inline unsigned Datetime::year() const { return d_value.datetime.year; }
 
inline unsigned Datetime::month() const { return d_value.datetime.month; }
 
inline unsigned Datetime::day() const { return d_value.datetime.day; }
 
inline unsigned Datetime::hours() const { return d_value.datetime.hours; }
 
inline unsigned Datetime::minutes() const { return d_value.datetime.minutes; }
 
inline unsigned Datetime::seconds() const { return d_value.datetime.seconds; }
 
inline unsigned Datetime::milliSeconds() const
{
    return d_value.datetime.milliSeconds;
}
 
inline unsigned Datetime::milliseconds() const
{
    return d_value.datetime.milliSeconds;
}
 
inline unsigned Datetime::microseconds() const
{
    return d_value.datetime.milliSeconds * 1000
            + d_value.picoseconds / 1000 / 1000;
}
 
inline unsigned Datetime::nanoseconds() const
{
    return d_value.datetime.milliSeconds * 1000 * 1000
            + d_value.picoseconds / 1000;
}
 
inline unsigned long long Datetime::picoseconds() const
{
    return d_value.datetime.milliSeconds * 1000LLU * 1000U * 1000U
            + d_value.picoseconds;
}
 
inline short Datetime::offset() const { return d_value.datetime.offset; }
 
inline const blpapi_Datetime_t& Datetime::rawValue() const
{
    return d_value.datetime;
}
 
inline const blpapi_HighPrecisionDatetime_t&
Datetime::rawHighPrecisionValue() const
{
    return d_value;
}
 
inline const Datetime::HighPrecision& Datetime::highPrecisionValue() const
{
    return d_value;
}
 
inline bool Datetime::isValid() const
{
    if ((hasParts(DatetimeParts::YEAR) || hasParts(DatetimeParts::MONTH)
                || hasParts(DatetimeParts::DAY))
            && !isValidDate(static_cast<int>(year()),
                    static_cast<int>(month()),
                    static_cast<int>(day()))) {
        return false;
    }
    if ((hasParts(DatetimeParts::HOURS) || hasParts(DatetimeParts::MINUTES)
                || hasParts(DatetimeParts::SECONDS)
                || hasParts(DatetimeParts::MILLISECONDS))
            && !isValidTime(static_cast<int>(hours()),
                    static_cast<int>(minutes()),
                    static_cast<int>(seconds()),
                    static_cast<int>(milliSeconds()))) {
        return false;
    }
    if (hasParts(DatetimeParts::FRACSECONDS)
            && (picoseconds() >= 1000LL * 1000 * 1000 * 1000)) {
        return false;
    }
    return true;
}
 
inline std::ostream& Datetime::print(
        std::ostream& stream, int level, int spacesPerLevel) const
{
    BLPAPI_CALL_HIGHPRECISIONDATETIME_PRINT(&d_value,
            StreamProxyOstream::writeToStream,
            &stream,
            level,
            spacesPerLevel);
    return stream;
}
 
inline bool operator==(const Datetime& lhs, const Datetime& rhs)
{
    if (lhs.parts() == rhs.parts()) {
        return (BLPAPI_CALL_HIGHPRECISIONDATETIME_COMPARE(
                        &lhs.rawHighPrecisionValue(),
                        &rhs.rawHighPrecisionValue())
                == 0);
    }
    return false;
}
 
inline bool operator!=(const Datetime& lhs, const Datetime& rhs)
{
    return !(lhs == rhs);
}
 
inline bool operator<(const Datetime& lhs, const Datetime& rhs)
{
    return (BLPAPI_CALL_HIGHPRECISIONDATETIME_COMPARE(
                    &lhs.rawHighPrecisionValue(), &rhs.rawHighPrecisionValue())
            < 0);
}
 
inline bool operator<=(const Datetime& lhs, const Datetime& rhs)
{
    return !(rhs < lhs);
}
 
inline bool operator>(const Datetime& lhs, const Datetime& rhs)
{
    return rhs < lhs;
}
 
inline bool operator>=(const Datetime& lhs, const Datetime& rhs)
{
    return !(lhs < rhs);
}
 
inline std::ostream& operator<<(std::ostream& stream, const Datetime& datetime)
{
    return datetime.print(stream, 0, -1);
}
 
// ------------------
// class DatetimeUtil
// ------------------
 
inline Datetime DatetimeUtil::fromTimePoint(
        const TimePoint& timePoint, Datetime::Offset offset)
{
    blpapi_HighPrecisionDatetime_t highPrecisionDatetime;
    BLPAPI_CALL_HIGHPRECISIONDATETIME_FROMTIMEPOINT(
            &highPrecisionDatetime, &timePoint, offset.d_minutesAheadOfUTC);
    return Datetime(highPrecisionDatetime);
}
 
// --------------
// namespace util
// --------------
constexpr const char *util::to_string(DatetimeParts::Value part)
{
    switch (part) {
    case DatetimeParts::YEAR:
        return "YEAR";
    case DatetimeParts::MONTH:
        return "MONTH";
    case DatetimeParts::DAY:
        return "DAY";
    case DatetimeParts::OFFSET:
        return "OFFSET";
    case DatetimeParts::HOURS:
        return "HOURS";
    case DatetimeParts::MINUTES:
        return "MINUTES";
    case DatetimeParts::SECONDS:
        return "SECONDS";
    case DatetimeParts::FRACSECONDS:
        return "FRACSECONDS";
    case DatetimeParts::DATE:
        return "DATE";
    case DatetimeParts::TIME:
        return "TIME";
    case DatetimeParts::TIMEFRACSECONDS:
        return "TIMEFRACSECONDS";
    }
    // Silence warnings on some compilers
    return "UNDEFINED";
}
 
} // close namespace blpapi
} // close namespace BloombergLP
 
#endif // #ifdef __cplusplus
 
#endif // #ifndef INCLUDED_BLPAPI_DATETIME