date.hpp

/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 
/*
 Copyright (C) 2000, 2001, 2002, 2003 RiskMap srl
 Copyright (C) 2003, 2004, 2005, 2006 StatPro Italia srl
 Copyright (C) 2004, 2005, 2006 Ferdinando Ametrano
 Copyright (C) 2006 Katiuscia Manzoni
 Copyright (C) 2006 Toyin Akin
 Copyright (C) 2015 Klaus Spanderen
 Copyright (C) 2020 Leonardo Arcari
 Copyright (C) 2020 Kline s.r.l.
 
 This file is part of QuantLib, a free-software/open-source library
 for financial quantitative analysts and developers - http://quantlib.org/
 
 QuantLib is free software: you can redistribute it and/or modify it
 under the terms of the QuantLib license.  You should have received a
 copy of the license along with this program; if not, please email
 <quantlib-dev@lists.sf.net>. The license is also available online at
 <http://quantlib.org/license.shtml>.
 
 This program is distributed in the hope that it will be useful, but WITHOUT
 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 FOR A PARTICULAR PURPOSE.  See the license for more details.
*/
 
#ifndef quantlib_date_hpp
#define quantlib_date_hpp
 
#include <ql/time/period.hpp>
#include <ql/time/weekday.hpp>
#include <ql/utilities/null.hpp>
 
#ifdef QL_HIGH_RESOLUTION_DATE
#include <boost/date_time/posix_time/ptime.hpp>
#include <boost/date_time/posix_time/posix_time_duration.hpp>
#endif
 
#include <cstdint>
#include <utility>
#include <functional>
#include <string>
 
 
namespace QuantLib {
 
 
    typedef Integer Day;
 
 
    enum Month { January   = 1,
                 February  = 2,
                 March     = 3,
                 April     = 4,
                 May       = 5,
                 June      = 6,
                 July      = 7,
                 August    = 8,
                 September = 9,
                 October   = 10,
                 November  = 11,
                 December  = 12,
                 Jan = 1,
                 Feb = 2,
                 Mar = 3,
                 Apr = 4,
                 Jun = 6,
                 Jul = 7,
                 Aug = 8,
                 Sep = 9,
                 Oct = 10,
                 Nov = 11,
                 Dec = 12
    };
 
    std::ostream& operator<<(std::ostream&, Month);
 
 
    typedef Integer Year;
 
#ifdef QL_HIGH_RESOLUTION_DATE
 
    typedef boost::posix_time::hours::hour_type Hour;
 
 
    typedef boost::posix_time::minutes::min_type Minute;
 
 
    typedef boost::posix_time::minutes::sec_type Second;
 
 
    typedef boost::posix_time::time_duration::fractional_seconds_type
        Millisecond;
 
 
    typedef boost::posix_time::time_duration::fractional_seconds_type
        Microsecond;
#endif
 
 
    class Date {
      public:
        typedef std::int_fast32_t serial_type;
 
 
        Date();
        explicit Date(Date::serial_type serialNumber);
        Date(Day d, Month m, Year y);
 
#ifdef QL_HIGH_RESOLUTION_DATE
        explicit Date(const boost::posix_time::ptime& localTime);
        Date(Day d, Month m, Year y,
             Hour hours, Minute minutes, Second seconds,
             Millisecond millisec = 0, Microsecond microsec = 0);
#endif
 
 
        Weekday weekday() const;
        Day dayOfMonth() const;
        Day dayOfYear() const;
        Month month() const;
        Year year() const;
        Date::serial_type serialNumber() const;
 
#ifdef QL_HIGH_RESOLUTION_DATE
        Hour hours() const;
        Minute minutes() const;
        Second seconds() const;
        Millisecond milliseconds() const;
        Microsecond microseconds() const;
 
        Time fractionOfDay() const;
        Time fractionOfSecond() const;
 
        const boost::posix_time::ptime& dateTime() const;
#endif
 
 
 
        Date& operator+=(Date::serial_type days);
        Date& operator+=(const Period&);
        Date& operator-=(Date::serial_type days);
        Date& operator-=(const Period&);
        Date& operator++();
        Date operator++(int );
        Date& operator--();
        Date operator--(int );
        Date operator+(Date::serial_type days) const;
        Date operator+(const Period&) const;
        Date operator-(Date::serial_type days) const;
        Date operator-(const Period&) const;
 
 
 
        static Date todaysDate();
        static Date minDate();
        static Date maxDate();
        static bool isLeap(Year y);
        static Date endOfMonth(const Date& d);
        static bool isEndOfMonth(const Date& d);
 
        static Date nextWeekday(const Date& d,
                                Weekday w);
 
        static Date nthWeekday(Size n,
                               Weekday w,
                               Month m,
                               Year y);
 
#ifdef QL_HIGH_RESOLUTION_DATE
        static Date localDateTime();
        static Date universalDateTime();
 
        static boost::posix_time::time_duration::tick_type ticksPerSecond();
#endif
 
 
      private:
        static Date::serial_type minimumSerialNumber();
        static Date::serial_type maximumSerialNumber();
        static void checkSerialNumber(Date::serial_type serialNumber);
 
#ifdef QL_HIGH_RESOLUTION_DATE
        boost::posix_time::ptime dateTime_;
#else
        Date::serial_type serialNumber_;
        static Date advance(const Date& d, Integer units, TimeUnit);
        static Integer monthLength(Month m, bool leapYear);
        static Integer monthOffset(Month m, bool leapYear);
        static Date::serial_type yearOffset(Year y);
#endif
    };
 
    Date::serial_type operator-(const Date&, const Date&);
    Time daysBetween(const Date&, const Date&);
 
    bool operator==(const Date&, const Date&);
    bool operator!=(const Date&, const Date&);
    bool operator<(const Date&, const Date&);
    bool operator<=(const Date&, const Date&);
    bool operator>(const Date&, const Date&);
    bool operator>=(const Date&, const Date&);
 
    std::size_t hash_value(const Date& d);
 
    std::ostream& operator<<(std::ostream&, const Date&);
 
    namespace detail {
 
        struct short_date_holder {
            explicit short_date_holder(const Date d) : d(d) {}
            Date d;
        };
        std::ostream& operator<<(std::ostream&, const short_date_holder&);
 
        struct long_date_holder {
            explicit long_date_holder(const Date& d) : d(d) {}
            Date d;
        };
        std::ostream& operator<<(std::ostream&, const long_date_holder&);
 
        struct iso_date_holder {
            explicit iso_date_holder(const Date& d) : d(d) {}
            Date d;
        };
        std::ostream& operator<<(std::ostream&, const iso_date_holder&);
 
        struct formatted_date_holder {
            formatted_date_holder(const Date& d, std::string f) : d(d), f(std::move(f)) {}
            Date d;
            std::string f;
        };
        std::ostream& operator<<(std::ostream&,
                                 const formatted_date_holder&);
 
#ifdef QL_HIGH_RESOLUTION_DATE
        struct iso_datetime_holder {
            explicit iso_datetime_holder(const Date& d) : d(d) {}
            Date d;
        };
        std::ostream& operator<<(std::ostream&, const iso_datetime_holder&);
#endif
    }
 
    namespace io {
 
 
        detail::short_date_holder short_date(const Date&);
 
 
        detail::long_date_holder long_date(const Date&);
 
 
        detail::iso_date_holder iso_date(const Date&);
 
 
        detail::formatted_date_holder formatted_date(const Date&,
                                                     const std::string& fmt);
 
#ifdef QL_HIGH_RESOLUTION_DATE
 
        detail::iso_datetime_holder iso_datetime(const Date&);
#endif
 
    }
 
    #ifdef QL_NULL_AS_FUNCTIONS
 
    template <>
    inline Date Null<Date>() {
        return {};
    }
 
    #else
 
    template <>
    class Null<Date> {
      public:
        Null() = default;
        operator Date() const { return {}; }
    };
 
    #endif
 
#ifndef QL_HIGH_RESOLUTION_DATE
    // inline definitions
 
    inline Weekday Date::weekday() const {
        Integer w = serialNumber_ % 7;
        return Weekday(w == 0 ? 7 : w);
    }
 
    inline Day Date::dayOfMonth() const {
        return dayOfYear() - monthOffset(month(),isLeap(year()));
    }
 
    inline Day Date::dayOfYear() const {
        return serialNumber_ - yearOffset(year());
    }
 
    inline Date::serial_type Date::serialNumber() const {
        return serialNumber_;
    }
 
    inline Date Date::operator+(Date::serial_type days) const {
        return Date(serialNumber_+days);
    }
 
    inline Date Date::operator-(Date::serial_type days) const {
        return Date(serialNumber_-days);
    }
 
    inline Date Date::operator+(const Period& p) const {
        return advance(*this,p.length(),p.units());
    }
 
    inline Date Date::operator-(const Period& p) const {
        return advance(*this,-p.length(),p.units());
    }
 
    inline Date Date::endOfMonth(const Date& d) {
        Month m = d.month();
        Year y = d.year();
        return {monthLength(m, isLeap(y)), m, y};
    }
 
    inline bool Date::isEndOfMonth(const Date& d) {
       return (d.dayOfMonth() == monthLength(d.month(), isLeap(d.year())));
    }
 
    inline Date::serial_type operator-(const Date& d1, const Date& d2) {
        return d1.serialNumber()-d2.serialNumber();
    }
 
    inline Time daysBetween(const Date& d1, const Date& d2) {
        return Time(d2-d1);
    }
 
    inline bool operator==(const Date& d1, const Date& d2) {
        return (d1.serialNumber() == d2.serialNumber());
    }
 
    inline bool operator!=(const Date& d1, const Date& d2) {
        return (d1.serialNumber() != d2.serialNumber());
    }
 
    inline bool operator<(const Date& d1, const Date& d2) {
        return (d1.serialNumber() < d2.serialNumber());
    }
 
    inline bool operator<=(const Date& d1, const Date& d2) {
        return (d1.serialNumber() <= d2.serialNumber());
    }
 
    inline bool operator>(const Date& d1, const Date& d2) {
        return (d1.serialNumber() > d2.serialNumber());
    }
 
    inline bool operator>=(const Date& d1, const Date& d2) {
        return (d1.serialNumber() >= d2.serialNumber());
    }
#endif
}
 
namespace std {
    template<>
    struct hash<QuantLib::Date> {
        std::size_t operator()(const QuantLib::Date& d) const {
            return QuantLib::hash_value(d);
        }
    };
}
 
#endif