calendar.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, 2007 StatPro Italia srl
 Copyright (C) 2006 Piter Dias
 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_calendar_hpp
#define quantlib_calendar_hpp
 
#include <ql/errors.hpp>
#include <ql/time/date.hpp>
#include <ql/time/businessdayconvention.hpp>
#include <ql/shared_ptr.hpp>
#include <set>
#include <vector>
#include <string>
 
namespace QuantLib {
 
    class Period;
 
 
    class Calendar {
      protected:
        class Impl {
          public:
            virtual ~Impl() = default;
            virtual std::string name() const = 0;
            virtual bool isBusinessDay(const Date&) const = 0;
            virtual bool isWeekend(Weekday) const = 0;
            std::set<Date> addedHolidays, removedHolidays;
        };
        ext::shared_ptr<Impl> impl_;
      public:
        Calendar() = default;
 
 
        bool empty() const;
 
        std::string name() const;
        const std::set<Date>& addedHolidays() const;
        
        const std::set<Date>& removedHolidays() const;
 
        void resetAddedAndRemovedHolidays();
 
        bool isBusinessDay(const Date& d) const;
        bool isHoliday(const Date& d) const;
        bool isWeekend(Weekday w) const;
        bool isEndOfMonth(const Date& d) const;
        Date endOfMonth(const Date& d) const;
 
        void addHoliday(const Date&);
        void removeHoliday(const Date&);
 
        std::vector<Date> holidayList(const Date& from,
                                      const Date& to,
                                      bool includeWeekEnds = false) const;
        std::vector<Date> businessDayList(const Date& from,
                                          const Date& to) const;
 
        Date adjust(const Date&,
                    BusinessDayConvention convention = Following) const;
        Date advance(const Date&,
                     Integer n,
                     TimeUnit unit,
                     BusinessDayConvention convention = Following,
                     bool endOfMonth = false) const;
        Date advance(const Date& date,
                     const Period& period,
                     BusinessDayConvention convention = Following,
                     bool endOfMonth = false) const;
        Date::serial_type businessDaysBetween(const Date& from,
                                              const Date& to,
                                              bool includeFirst = true,
                                              bool includeLast = false) const;
 
      protected:
 
        class WesternImpl : public Impl {
          public:
            bool isWeekend(Weekday) const override;
            static Day easterMonday(Year);
        };
 
        class OrthodoxImpl : public Impl {
          public:
            bool isWeekend(Weekday) const override;
            static Day easterMonday(Year);
        };
    };
 
    bool operator==(const Calendar&, const Calendar&);
 
    bool operator!=(const Calendar&, const Calendar&);
 
    std::ostream& operator<<(std::ostream&, const Calendar&);
 
 
    // inline definitions
 
    inline bool Calendar::empty() const {
        return !impl_;
    }
 
    inline std::string Calendar::name() const {
        QL_REQUIRE(impl_, "no calendar implementation provided");
        return impl_->name();
    }
 
    inline const std::set<Date>& Calendar::addedHolidays() const {
        QL_REQUIRE(impl_, "no calendar implementation provided");
 
        return impl_->addedHolidays;
    }
 
    inline const std::set<Date>& Calendar::removedHolidays() const {
        QL_REQUIRE(impl_, "no calendar implementation provided");
 
        return impl_->removedHolidays;
    }
 
    inline bool Calendar::isBusinessDay(const Date& d) const {
        QL_REQUIRE(impl_, "no calendar implementation provided");
 
#ifdef QL_HIGH_RESOLUTION_DATE
        const Date _d(d.dayOfMonth(), d.month(), d.year());
#else
        const Date& _d = d;
#endif
 
        if (!impl_->addedHolidays.empty() &&
            impl_->addedHolidays.find(_d) != impl_->addedHolidays.end())
            return false;
 
        if (!impl_->removedHolidays.empty() &&
            impl_->removedHolidays.find(_d) != impl_->removedHolidays.end())
            return true;
 
        return impl_->isBusinessDay(_d);
    }
 
    inline bool Calendar::isEndOfMonth(const Date& d) const {
        return (d.month() != adjust(d+1).month());
    }
 
    inline Date Calendar::endOfMonth(const Date& d) const {
        return adjust(Date::endOfMonth(d), Preceding);
    }
 
    inline bool Calendar::isHoliday(const Date& d) const {
        return !isBusinessDay(d);
    }
 
    inline bool Calendar::isWeekend(Weekday w) const {
        QL_REQUIRE(impl_, "no calendar implementation provided");
        return impl_->isWeekend(w);
    }
 
    inline bool operator==(const Calendar& c1, const Calendar& c2) {
        return (c1.empty() && c2.empty())
            || (!c1.empty() && !c2.empty() && c1.name() == c2.name());
    }
 
    inline bool operator!=(const Calendar& c1, const Calendar& c2) {
        return !(c1 == c2);
    }
 
    inline std::ostream& operator<<(std::ostream& out, const Calendar &c) {
        return out << c.name();
    }
 
}
 
#endif