date_time_facet.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_FACET_HPP_INCLUDED
#define BOOST_LOCALE_DATE_TIME_FACET_HPP_INCLUDED
 
#include <boost/locale/config.hpp>
#include <boost/cstdint.hpp>
#include <locale>
 
#ifdef BOOST_MSVC
#    pragma warning(push)
#    pragma warning(disable : 4275 4251 4231 4660)
#endif
 
namespace boost { namespace locale {
 
    namespace period {
 
        namespace marks {
 
            enum period_mark {
                invalid,       
                era,           
                year,          
                extended_year, 
                month,         
                day,           
                day_of_year,   
                day_of_week,   
                day_of_week_in_month, 
                day_of_week_local, 
                hour,              
                hour_12,           
                am_pm,             
                minute,            
                second,            
                week_of_year,      
                week_of_month,     
                first_day_of_week, 
            };
 
        } // namespace marks
 
        class period_type {
        public:
            period_type(marks::period_mark m = marks::invalid) : mark_(m) {}
 
            marks::period_mark mark() const { return mark_; }
 
            bool operator==(const period_type& other) const { return mark() == other.mark(); }
            bool operator!=(const period_type& other) const { return mark() != other.mark(); }
 
        private:
            marks::period_mark mark_;
        };
 
    } // namespace period
 
    struct posix_time {
        int64_t seconds;      
        uint32_t nanoseconds; 
    };
 
    class BOOST_LOCALE_DECL abstract_calendar {
    public:
        enum value_type {
            absolute_minimum, 
            actual_minimum,   
            greatest_minimum, 
            current,          
            least_maximum,    
            actual_maximum,   
            absolute_maximum, 
        };
 
        enum update_type {
            move, 
            roll, 
        };
 
        enum calendar_option_type {
            is_gregorian, 
            is_dst        
        };
 
        virtual abstract_calendar* clone() const = 0;
 
        virtual void set_value(period::marks::period_mark m, int value) = 0;
 
        virtual void normalize() = 0;
 
        virtual int get_value(period::marks::period_mark m, value_type v) const = 0;
 
        virtual void set_time(const posix_time& p) = 0;
        virtual posix_time get_time() const = 0;
        virtual double get_time_ms() const = 0;
 
        virtual void set_option(calendar_option_type opt, int v) = 0;
        virtual int get_option(calendar_option_type opt) const = 0;
 
        virtual void adjust_value(period::marks::period_mark m, update_type u, int difference) = 0;
 
        virtual int difference(const abstract_calendar& other, period::marks::period_mark m) const = 0;
 
        virtual void set_timezone(const std::string& tz) = 0;
        virtual std::string get_timezone() const = 0;
 
        virtual bool same(const abstract_calendar* other) const = 0;
 
        virtual ~abstract_calendar();
    };
 
    class BOOST_LOCALE_DECL calendar_facet : public std::locale::facet {
    public:
        calendar_facet(size_t refs = 0) : std::locale::facet(refs) {}
        ~calendar_facet();
        virtual abstract_calendar* create_calendar() const = 0;
 
        static std::locale::id id;
    };
 
}} // namespace boost::locale
 
#ifdef BOOST_MSVC
#    pragma warning(pop)
#endif
 
#endif