date_time.hpp

//
// Copyright (c) 2009-2011 Artyom Beilis (Tonkikh)
//
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt

#ifndef BOOST_LOCALE_DATE_TIME_HPP_INCLUDED
#define BOOST_LOCALE_DATE_TIME_HPP_INCLUDED

#include <boost/locale/date_time_facet.hpp>
#include <boost/locale/formatting.hpp>
#include <boost/locale/hold_ptr.hpp>
#include <boost/locale/time_zone.hpp>
#include <locale>
#include <stdexcept>
#include <vector>

#ifdef BOOST_MSVC
#    pragma warning(push)
#    pragma warning(disable : 4275 4251 4231 4660)
#endif

namespace boost { namespace locale {

    class BOOST_SYMBOL_VISIBLE date_time_error : public std::runtime_error {
    public:
        date_time_error(const std::string& e) : std::runtime_error(e) {}
    };

    struct date_time_period {
        period::period_type type; 
        int value;                
        date_time_period operator+() const { return *this; }
        date_time_period operator-() const { return date_time_period(type, -value); }

        date_time_period(period::period_type f = period::period_type(), int v = 1) : type(f), value(v) {}
    };

    namespace period {
        inline period_type invalid()
        {
            return period_type(marks::invalid);
        }
        inline period_type era()
        {
            return period_type(marks::era);
        }
        inline period_type year()
        {
            return period_type(marks::year);
        }
        inline period_type extended_year()
        {
            return period_type(marks::extended_year);
        }
        inline period_type month()
        {
            return period_type(marks::month);
        }
        inline period_type day()
        {
            return period_type(marks::day);
        }
        inline period_type day_of_year()
        {
            return period_type(marks::day_of_year);
        }
        inline period_type day_of_week()
        {
            return period_type(marks::day_of_week);
        }
        inline period_type day_of_week_in_month()
        {
            return period_type(marks::day_of_week_in_month);
        }
        inline period_type day_of_week_local()
        {
            return period_type(marks::day_of_week_local);
        }
        inline period_type hour()
        {
            return period_type(marks::hour);
        }
        inline period_type hour_12()
        {
            return period_type(marks::hour_12);
        }
        inline period_type am_pm()
        {
            return period_type(marks::am_pm);
        }
        inline period_type minute()
        {
            return period_type(marks::minute);
        }
        inline period_type second()
        {
            return period_type(marks::second);
        }
        inline period_type week_of_year()
        {
            return period_type(marks::week_of_year);
        }
        inline period_type week_of_month()
        {
            return period_type(marks::week_of_month);
        }
        inline period_type first_day_of_week()
        {
            return period_type(marks::first_day_of_week);
        }

        inline date_time_period era(int v)
        {
            return date_time_period(era(), v);
        }
        inline date_time_period year(int v)
        {
            return date_time_period(year(), v);
        }
        inline date_time_period extended_year(int v)
        {
            return date_time_period(extended_year(), v);
        }
        inline date_time_period month(int v)
        {
            return date_time_period(month(), v);
        }
        inline date_time_period day(int v)
        {
            return date_time_period(day(), v);
        }
        inline date_time_period day_of_year(int v)
        {
            return date_time_period(day_of_year(), v);
        }
        inline date_time_period day_of_week(int v)
        {
            return date_time_period(day_of_week(), v);
        }
        inline date_time_period day_of_week_in_month(int v)
        {
            return date_time_period(day_of_week_in_month(), v);
        }
        inline date_time_period day_of_week_local(int v)
        {
            return date_time_period(day_of_week_local(), v);
        }
        inline date_time_period hour(int v)
        {
            return date_time_period(hour(), v);
        }
        inline date_time_period hour_12(int v)
        {
            return date_time_period(hour_12(), v);
        }
        inline date_time_period am_pm(int v)
        {
            return date_time_period(am_pm(), v);
        }
        inline date_time_period minute(int v)
        {
            return date_time_period(minute(), v);
        }
        inline date_time_period second(int v)
        {
            return date_time_period(second(), v);
        }
        inline date_time_period week_of_year(int v)
        {
            return date_time_period(week_of_year(), v);
        }
        inline date_time_period week_of_month(int v)
        {
            return date_time_period(week_of_month(), v);
        }
        inline date_time_period first_day_of_week(int v)
        {
            return date_time_period(first_day_of_week(), v);
        }

        inline date_time_period january()
        {
            return date_time_period(month(), 0);
        }
        inline date_time_period february()
        {
            return date_time_period(month(), 1);
        }
        inline date_time_period march()
        {
            return date_time_period(month(), 2);
        }
        inline date_time_period april()
        {
            return date_time_period(month(), 3);
        }
        inline date_time_period may()
        {
            return date_time_period(month(), 4);
        }
        inline date_time_period june()
        {
            return date_time_period(month(), 5);
        }
        inline date_time_period july()
        {
            return date_time_period(month(), 6);
        }
        inline date_time_period august()
        {
            return date_time_period(month(), 7);
        }
        inline date_time_period september()
        {
            return date_time_period(month(), 8);
        }
        inline date_time_period october()
        {
            return date_time_period(month(), 9);
        }
        inline date_time_period november()
        {
            return date_time_period(month(), 10);
        }
        inline date_time_period december()
        {
            return date_time_period(month(), 11);
        }

        inline date_time_period sunday()
        {
            return date_time_period(day_of_week(), 1);
        }
        inline date_time_period monday()
        {
            return date_time_period(day_of_week(), 2);
        }
        inline date_time_period tuesday()
        {
            return date_time_period(day_of_week(), 3);
        }
        inline date_time_period wednesday()
        {
            return date_time_period(day_of_week(), 4);
        }
        inline date_time_period thursday()
        {
            return date_time_period(day_of_week(), 5);
        }
        inline date_time_period friday()
        {
            return date_time_period(day_of_week(), 6);
        }
        inline date_time_period saturday()
        {
            return date_time_period(day_of_week(), 7);
        }
        inline date_time_period am()
        {
            return date_time_period(am_pm(), 0);
        }
        inline date_time_period pm()
        {
            return date_time_period(am_pm(), 1);
        }

        inline date_time_period operator+(period::period_type f)
        {
            return date_time_period(f);
        }
        inline date_time_period operator-(period::period_type f)
        {
            return date_time_period(f, -1);
        }

        template<typename T>
        date_time_period operator*(period::period_type f, T v)
        {
            return date_time_period(f, v);
        }

        template<typename T>
        date_time_period operator*(T v, period::period_type f)
        {
            return date_time_period(f, v);
        }
        template<typename T>
        date_time_period operator*(T v, date_time_period f)
        {
            return date_time_period(f.type, f.value * v);
        }

        template<typename T>
        date_time_period operator*(date_time_period f, T v)
        {
            return date_time_period(f.type, f.value * v);
        }

    } // namespace period

    class date_time_period_set {
    public:
        date_time_period_set() {}

        date_time_period_set(period::period_type f) { basic_[0] = date_time_period(f); }

        date_time_period_set(const date_time_period& fl) { basic_[0] = fl; }

        void add(date_time_period f)
        {
            size_t n = size();
            if(n < 4)
                basic_[n] = f;
            else
                periods_.push_back(f);
        }

        size_t size() const
        {
            if(basic_[0].type == period::period_type())
                return 0;
            if(basic_[1].type == period::period_type())
                return 1;
            if(basic_[2].type == period::period_type())
                return 2;
            if(basic_[3].type == period::period_type())
                return 3;
            return 4 + periods_.size();
        }

        const date_time_period& operator[](size_t n) const
        {
            if(n >= size())
                throw std::out_of_range("Invalid index to date_time_period");
            if(n < 4)
                return basic_[n];
            else
                return periods_[n - 4];
        }

    private:
        date_time_period basic_[4];
        std::vector<date_time_period> periods_;
    };

    inline date_time_period_set operator+(const date_time_period_set& a, const date_time_period_set& b)
    {
        date_time_period_set s(a);
        for(unsigned i = 0; i < b.size(); i++)
            s.add(b[i]);
        return s;
    }

    inline date_time_period_set operator-(const date_time_period_set& a, const date_time_period_set& b)
    {
        date_time_period_set s(a);
        for(unsigned i = 0; i < b.size(); i++)
            s.add(-b[i]);
        return s;
    }

    class BOOST_LOCALE_DECL calendar {
    public:
        calendar(std::ios_base& ios);

        calendar(const std::locale& l, const std::string& zone);

        calendar(const std::locale& l);


        calendar(const std::string& zone);

        calendar();
        ~calendar();

        calendar(const calendar& other);
        calendar& operator=(const calendar& other);

        int minimum(period::period_type f) const;
        int greatest_minimum(period::period_type f) const;
        int maximum(period::period_type f) const;
        int least_maximum(period::period_type f) const;

        int first_day_of_week() const;

        std::locale get_locale() const;
        std::string get_time_zone() const;

        bool is_gregorian() const;

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

    private:
        friend class date_time;
        std::locale locale_;
        std::string tz_;
        hold_ptr<abstract_calendar> impl_;
    };


    class BOOST_LOCALE_DECL date_time {
    public:
        date_time();

        date_time(const date_time& other);
        // Move construct a new date_time
        date_time(date_time&& other) = default;

        date_time(const date_time& other, const date_time_period_set& set);

        date_time& operator=(const date_time& other);
        // Move assign a date_time
        date_time& operator=(date_time&& other) = default;

        date_time(double time);

        date_time(double time, const calendar& cal);

        date_time(const calendar& cal);

        date_time(const date_time_period_set& set);

        date_time(const date_time_period_set& set, const calendar& cal);

        date_time& operator=(const date_time_period_set& f);

        void set(period::period_type f, int v);

        int get(period::period_type f) const;
        int operator/(period::period_type f) const { return get(f); }

        date_time operator+(period::period_type f) const { return *this + date_time_period(f); }
        date_time operator-(period::period_type f) const { return *this - date_time_period(f); }
        date_time& operator+=(period::period_type f) { return *this += date_time_period(f); }
        date_time& operator-=(period::period_type f) { return *this -= date_time_period(f); }

        date_time operator<<(period::period_type f) const { return *this << date_time_period(f); }
        date_time operator>>(period::period_type f) const { return *this >> date_time_period(f); }
        date_time& operator<<=(period::period_type f) { return *this <<= date_time_period(f); }
        date_time& operator>>=(period::period_type f) { return *this >>= date_time_period(f); }

        date_time operator+(const date_time_period& v) const;
        date_time operator-(const date_time_period& v) const;
        date_time& operator+=(const date_time_period& v);
        date_time& operator-=(const date_time_period& v);

        date_time operator<<(const date_time_period& v) const;
        date_time operator>>(const date_time_period& v) const;
        date_time& operator<<=(const date_time_period& v);
        date_time& operator>>=(const date_time_period& v);

        date_time operator+(const date_time_period_set& v) const;
        date_time operator-(const date_time_period_set& v) const;
        date_time& operator+=(const date_time_period_set& v);
        date_time& operator-=(const date_time_period_set& v);

        date_time operator<<(const date_time_period_set& v) const;
        date_time operator>>(const date_time_period_set& v) const;
        date_time& operator<<=(const date_time_period_set& v);
        date_time& operator>>=(const date_time_period_set& v);

        double time() const;
        void time(double v);

        bool operator==(const date_time& other) const;
        bool operator!=(const date_time& other) const;
        bool operator<(const date_time& other) const;
        bool operator>(const date_time& other) const;
        bool operator<=(const date_time& other) const;
        bool operator>=(const date_time& other) const;

        void swap(date_time& other);

        int difference(const date_time& other, period::period_type f) const;

        int minimum(period::period_type f) const;
        int maximum(period::period_type f) const;

        bool is_in_daylight_saving_time() const;

    private:
        hold_ptr<abstract_calendar> impl_;
    };

    template<typename CharType>
    std::basic_ostream<CharType>& operator<<(std::basic_ostream<CharType>& out, const date_time& t)
    {
        double time_point = t.time();
        uint64_t display_flags = ios_info::get(out).display_flags();
        if(display_flags == flags::date || display_flags == flags::time || display_flags == flags::datetime
           || display_flags == flags::strftime)
        {
            out << time_point;
        } else {
            ios_info::get(out).display_flags(flags::datetime);
            out << time_point;
            ios_info::get(out).display_flags(display_flags);
        }
        return out;
    }

    template<typename CharType>
    std::basic_istream<CharType>& operator>>(std::basic_istream<CharType>& in, date_time& t)
    {
        double v;
        uint64_t display_flags = ios_info::get(in).display_flags();
        if(display_flags == flags::date || display_flags == flags::time || display_flags == flags::datetime
           || display_flags == flags::strftime)
        {
            in >> v;
        } else {
            ios_info::get(in).display_flags(flags::datetime);
            in >> v;
            ios_info::get(in).display_flags(display_flags);
        }
        if(!in.fail())
            t.time(v);
        return in;
    }

#ifdef BOOST_MSVC
#    pragma warning(push)
#    pragma warning(disable : 4512) // assignment operator could not be generated
#endif

    class date_time_duration {
    public:
        date_time_duration(const date_time& first, const date_time& second) : s_(first), e_(second) {}

        int get(period::period_type f) const { return start().difference(end(), f); }
        int operator/(period::period_type f) const { return start().difference(end(), f); }

        const date_time& start() const { return s_; }
        const date_time& end() const { return e_; }

    private:
        const date_time& s_;
        const date_time& e_;
    };
#ifdef BOOST_MSVC
#    pragma warning(pop)
#endif

    inline date_time_duration operator-(const date_time& later, const date_time& earlier)
    {
        return date_time_duration(earlier, later);
    }

    namespace period {
        inline int era(const date_time& dt)
        {
            return dt.get(era());
        }
        inline int year(const date_time& dt)
        {
            return dt.get(year());
        }
        inline int extended_year(const date_time& dt)
        {
            return dt.get(extended_year());
        }
        inline int month(const date_time& dt)
        {
            return dt.get(month());
        }
        inline int day(const date_time& dt)
        {
            return dt.get(day());
        }
        inline int day_of_year(const date_time& dt)
        {
            return dt.get(day_of_year());
        }
        inline int day_of_week(const date_time& dt)
        {
            return dt.get(day_of_week());
        }
        inline int day_of_week_in_month(const date_time& dt)
        {
            return dt.get(day_of_week_in_month());
        }
        inline int day_of_week_local(const date_time& dt)
        {
            return dt.get(day_of_week_local());
        }
        inline int hour(const date_time& dt)
        {
            return dt.get(hour());
        }
        inline int hour_12(const date_time& dt)
        {
            return dt.get(hour_12());
        }
        inline int am_pm(const date_time& dt)
        {
            return dt.get(am_pm());
        }
        inline int minute(const date_time& dt)
        {
            return dt.get(minute());
        }
        inline int second(const date_time& dt)
        {
            return dt.get(second());
        }
        inline int week_of_year(const date_time& dt)
        {
            return dt.get(week_of_year());
        }
        inline int week_of_month(const date_time& dt)
        {
            return dt.get(week_of_month());
        }
        inline int first_day_of_week(const date_time& dt)
        {
            return dt.get(first_day_of_week());
        }

        inline int era(const date_time_duration& dt)
        {
            return dt.get(era());
        }
        inline int year(const date_time_duration& dt)
        {
            return dt.get(year());
        }
        inline int extended_year(const date_time_duration& dt)
        {
            return dt.get(extended_year());
        }
        inline int month(const date_time_duration& dt)
        {
            return dt.get(month());
        }
        inline int day(const date_time_duration& dt)
        {
            return dt.get(day());
        }
        inline int day_of_year(const date_time_duration& dt)
        {
            return dt.get(day_of_year());
        }
        inline int day_of_week(const date_time_duration& dt)
        {
            return dt.get(day_of_week());
        }
        inline int day_of_week_in_month(const date_time_duration& dt)
        {
            return dt.get(day_of_week_in_month());
        }
        inline int day_of_week_local(const date_time_duration& dt)
        {
            return dt.get(day_of_week_local());
        }
        inline int hour(const date_time_duration& dt)
        {
            return dt.get(hour());
        }
        inline int hour_12(const date_time_duration& dt)
        {
            return dt.get(hour_12());
        }
        inline int am_pm(const date_time_duration& dt)
        {
            return dt.get(am_pm());
        }
        inline int minute(const date_time_duration& dt)
        {
            return dt.get(minute());
        }
        inline int second(const date_time_duration& dt)
        {
            return dt.get(second());
        }
        inline int week_of_year(const date_time_duration& dt)
        {
            return dt.get(week_of_year());
        }
        inline int week_of_month(const date_time_duration& dt)
        {
            return dt.get(week_of_month());
        }
        inline int first_day_of_week(const date_time_duration& dt)
        {
            return dt.get(first_day_of_week());
        }

    } // namespace period


}} // namespace boost::locale

#ifdef BOOST_MSVC
#    pragma warning(pop)
#endif


#endif