comparison DEPENDENCIES/generic/include/boost/locale/formatting.hpp @ 16:2665513ce2d3

Add boost headers

+//
+//  Copyright (c) 2009-2011 Artyom Beilis (Tonkikh)
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+#ifndef BOOST_LOCALE_FORMATTING_HPP_INCLUDED
+#define BOOST_LOCALE_FORMATTING_HPP_INCLUDED
+
+#include <boost/locale/config.hpp>
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4275 4251 4231 4660)
+#endif
+#include <boost/cstdint.hpp>
+#include <boost/locale/time_zone.hpp>
+#include <ostream>
+#include <istream>
+#include <string>
+#include <string.h>
+#include <typeinfo>
+
+namespace boost {
+    namespace locale {
+        ///
+        /// \brief This namespace holds additional formatting
+        /// flags that can be set using ios_info.
+        ///
+        namespace flags {
+            ///
+            /// Formatting flags, each one of them has corresponding manipulation
+            /// in namespace \a as
+            ///
+            typedef enum {
+                posix               = 0,
+                number              = 1,
+                currency            = 2,
+                percent             = 3,
+                date                = 4,
+                time                = 5,
+                datetime            = 6,
+                strftime            = 7,
+                spellout            = 8,
+                ordinal             = 9,
+
+                display_flags_mask  = 31,
+
+                currency_default    = 0 << 5,
+                currency_iso        = 1 << 5,
+                currency_national   = 2 << 5,
+
+                currency_flags_mask = 3 << 5,
+
+                time_default        = 0 << 7,
+                time_short          = 1 << 7,
+                time_medium         = 2 << 7,
+                time_long           = 3 << 7,
+                time_full           = 4 << 7,
+                time_flags_mask     = 7 << 7,
+
+                date_default        = 0 << 10,
+                date_short          = 1 << 10,
+                date_medium         = 2 << 10,
+                date_long           = 3 << 10,
+                date_full           = 4 << 10,
+                date_flags_mask     = 7 << 10,
+
+                datetime_flags_mask = date_flags_mask | time_flags_mask
+
+            } display_flags_type;
+
+            ///
+            /// Special string patters that can be used
+            /// for text formatting
+            ///
+            typedef enum {
+                datetime_pattern,   ///< strftime like formatting
+                time_zone_id        ///< time zone name
+            } pattern_type;
+
+            ///
+            /// Special integer values that can be used for formatting
+            ///
+            typedef enum {
+                domain_id           ///< Domain code - for message formatting
+            } value_type;
+
+            
+        } // flags
+
+        ///
+        /// \brief This class holds an external data - beyond existing fmtflags that std::ios_base holds
+        ///
+        /// You should almost never create this object directly. Instead, you should access it via ios_info::get(stream_object)
+        /// static member function. It automatically creates default formatting data for that stream
+        ///
+        class BOOST_LOCALE_DECL ios_info {
+        public:
+
+            /// \cond INTERNAL
+
+            ios_info();
+            ios_info(ios_info const &);
+            ios_info const &operator=(ios_info const &);
+            ~ios_info();
+
+            /// \endcond
+
+            ///
+            /// Get ios_info instance for specific stream object
+            ///
+            static ios_info &get(std::ios_base &ios);
+
+            ///
+            /// Set a flags that define a way for format data like number, spell, currency etc.
+            ///
+            void display_flags(uint64_t flags);
+            
+            ///
+            /// Set a flags that define how to format currency
+            ///
+            void currency_flags(uint64_t flags);
+            
+            ///
+            /// Set a flags that define how to format date
+            ///
+            void date_flags(uint64_t flags);
+            
+            ///
+            /// Set a flags that define how to format time
+            ///
+            void time_flags(uint64_t flags);
+            
+            ///
+            /// Set a flags that define how to format both date and time
+            ///
+            void datetime_flags(uint64_t flags);
+            
+            ///
+            /// Set special message domain identification
+            ///
+            void domain_id(int);
+            
+            ///
+            /// Set time zone for formatting dates and time
+            ///
+            void time_zone(std::string const &);
+            
+
+            ///
+            /// Set date/time pattern (strftime like)
+            ///
+            template<typename CharType>
+            void date_time_pattern(std::basic_string<CharType> const &str)
+            {
+                string_set &s = date_time_pattern_set();
+                s.set<CharType>(str.c_str());
+            }
+
+
+            ///
+            /// Get a flags that define a way for format data like number, spell, currency etc.
+            ///
+            uint64_t display_flags() const;
+            
+            ///
+            /// Get a flags that define how to format currency
+            ///
+            uint64_t currency_flags() const;
+
+            
+            ///
+            /// Get a flags that define how to format date
+            ///
+            uint64_t date_flags() const;
+            
+            ///
+            /// Get a flags that define how to format time
+            ///
+            uint64_t time_flags() const;
+
+            ///
+            /// Get a flags that define how to format both date and time
+            ///
+            uint64_t datetime_flags() const;
+            
+            ///
+            /// Get special message domain identification
+            ///
+            int domain_id() const;
+            
+            ///
+            /// Get time zone for formatting dates and time
+            ///
+            std::string time_zone() const;
+            
+            ///
+            /// Get date/time pattern (strftime like)
+            ///
+            template<typename CharType>
+            std::basic_string<CharType> date_time_pattern() const
+            {
+                string_set const &s = date_time_pattern_set();
+                return s.get<CharType>();
+            }
+            
+            /// \cond INTERNAL
+            void on_imbue();
+            /// \endcond
+            
+        private:
+
+            class string_set;
+
+            string_set const &date_time_pattern_set() const;
+            string_set &date_time_pattern_set();
+            
+            class BOOST_LOCALE_DECL string_set {
+            public:
+                string_set(); 
+                ~string_set();
+                string_set(string_set const &other);
+                string_set const &operator=(string_set const &other);
+                void swap(string_set &other);
+                
+                template<typename Char>
+                void set(Char const *s)
+                {
+                    delete [] ptr;
+                    ptr = 0;
+                    type=&typeid(Char);
+                    Char const *end = s;
+                    while(*end!=0) end++;
+                    // if ptr = 0 it does not matter what is value of size
+                    size = sizeof(Char)*(end - s+1);
+                    ptr = new char[size];
+                    memcpy(ptr,s,size);
+                }
+
+                template<typename Char>
+                std::basic_string<Char> get() const
+                {
+                    if(type==0 || *type!=typeid(Char))
+                        throw std::bad_cast();
+                    std::basic_string<Char> result = reinterpret_cast<Char const *>(ptr);
+                    return result;
+                }
+
+            private:
+                std::type_info const *type;
+                size_t size;
+                char *ptr;
+            };
+
+            uint64_t flags_;
+            int domain_id_;
+            std::string time_zone_;
+            string_set datetime_;
+
+            struct data;
+            data *d;
+
+        };
+
+
+        ///
+        /// \brief This namespace includes all manipulators that can be used on IO streams
+        ///
+        namespace as {
+            ///
+            /// \defgroup manipulators I/O Stream manipulators
+            ///
+            /// @{
+            ///
+
+            ///
+            /// Format values with "POSIX" or "C"  locale. Note, if locale was created with additional non-classic locale then
+            /// These numbers may be localized
+            ///
+            
+            inline std::ios_base & posix(std::ios_base & ios)
+            {
+                ios_info::get(ios).display_flags(flags::posix);
+                return ios;
+            }
+
+            ///
+            /// Format a number. Note, unlike standard number formatting, integers would be treated like real numbers when std::fixed or
+            /// std::scientific manipulators were applied
+            ///
+            inline std::ios_base & number(std::ios_base & ios)
+            {
+                ios_info::get(ios).display_flags(flags::number);
+                return ios;
+            }
+            
+            ///
+            /// Format currency, number is treated like amount of money
+            ///
+            inline std::ios_base & currency(std::ios_base & ios)
+            {
+                ios_info::get(ios).display_flags(flags::currency);
+                return ios;
+            }
+            
+            ///
+            /// Format percent, value 0.3 is treated as 30%.
+            ///
+            inline std::ios_base & percent(std::ios_base & ios)
+            {
+                ios_info::get(ios).display_flags(flags::percent);
+                return ios;
+            }
+            
+            ///
+            /// Format a date, number is treated as POSIX time
+            ///
+            inline std::ios_base & date(std::ios_base & ios)
+            {
+                ios_info::get(ios).display_flags(flags::date);
+                return ios;
+            }
+
+            ///
+            /// Format a time, number is treated as POSIX time
+            ///
+            inline std::ios_base & time(std::ios_base & ios)
+            {
+                ios_info::get(ios).display_flags(flags::time);
+                return ios;
+            }
+
+            ///
+            /// Format a date and time, number is treated as POSIX time
+            ///
+            inline std::ios_base & datetime(std::ios_base & ios)
+            {
+                ios_info::get(ios).display_flags(flags::datetime);
+                return ios;
+            }
+
+            ///
+            /// Create formatted date time, Please note, this manipulator only changes formatting mode,
+            /// and not format itself, so you are probably looking for ftime manipulator
+            ///
+            inline std::ios_base & strftime(std::ios_base & ios)
+            {
+                ios_info::get(ios).display_flags(flags::strftime);
+                return ios;
+            }
+            
+            ///
+            /// Spell the number, like "one hundred and ten"
+            ///
+            inline std::ios_base & spellout(std::ios_base & ios)
+            {
+                ios_info::get(ios).display_flags(flags::spellout);
+                return ios;
+            }
+            
+            ///
+            /// Write an order of the number like 4th.
+            ///
+            inline std::ios_base & ordinal(std::ios_base & ios)
+            {
+                ios_info::get(ios).display_flags(flags::ordinal);
+                return ios;
+            }
+
+            ///
+            /// Set default currency formatting style -- national, like "$"
+            ///
+            inline std::ios_base & currency_default(std::ios_base & ios)
+            {
+                ios_info::get(ios).currency_flags(flags::currency_default);
+                return ios;
+            }
+
+            ///
+            /// Set ISO currency formatting style, like "USD", (requires ICU >= 4.2)
+            ///
+            inline std::ios_base & currency_iso(std::ios_base & ios)
+            {
+                ios_info::get(ios).currency_flags(flags::currency_iso);
+                return ios;
+            }
+
+            ///
+            /// Set national currency formatting style, like "$"
+            ///
+            inline std::ios_base & currency_national(std::ios_base & ios)
+            {
+                ios_info::get(ios).currency_flags(flags::currency_national);
+                return ios;
+            }
+
+            ///
+            /// set default (medium) time formatting style
+            ///
+            inline std::ios_base & time_default(std::ios_base & ios)
+            {
+                ios_info::get(ios).time_flags(flags::time_default);
+                return ios;
+            }
+
+            ///
+            /// set short time formatting style
+            ///
+            inline std::ios_base & time_short(std::ios_base & ios)
+            {
+                ios_info::get(ios).time_flags(flags::time_short);
+                return ios;
+            }
+
+            ///
+            /// set medium time formatting style
+            ///
+            inline std::ios_base & time_medium(std::ios_base & ios)
+            {
+                ios_info::get(ios).time_flags(flags::time_medium);
+                return ios;
+            }
+
+            ///
+            /// set long time formatting style
+            ///
+            inline std::ios_base & time_long(std::ios_base & ios)
+            {
+                ios_info::get(ios).time_flags(flags::time_long);
+                return ios;
+            }
+
+            ///
+            /// set full time formatting style
+            ///
+            inline std::ios_base & time_full(std::ios_base & ios)
+            {
+                ios_info::get(ios).time_flags(flags::time_full);
+                return ios;
+            }
+
+            ///
+            /// set default (medium) date formatting style
+            ///
+            inline std::ios_base & date_default(std::ios_base & ios)
+            {
+                ios_info::get(ios).date_flags(flags::date_default);
+                return ios;
+            }
+
+            ///
+            /// set short date formatting style
+            ///
+            inline std::ios_base & date_short(std::ios_base & ios)
+            {
+                ios_info::get(ios).date_flags(flags::date_short);
+                return ios;
+            }
+
+            ///
+            /// set medium date formatting style
+            ///
+            inline std::ios_base & date_medium(std::ios_base & ios)
+            {
+                ios_info::get(ios).date_flags(flags::date_medium);
+                return ios;
+            }
+
+            ///
+            /// set long date formatting style
+            ///
+            inline std::ios_base & date_long(std::ios_base & ios)
+            {
+                ios_info::get(ios).date_flags(flags::date_long);
+                return ios;
+            }
+
+            ///
+            /// set full date formatting style
+            ///
+            inline std::ios_base & date_full(std::ios_base & ios)
+            {
+                ios_info::get(ios).date_flags(flags::date_full);
+                return ios;
+            }            
+            
+            
+            /// \cond INTERNAL 
+            namespace details {
+                template<typename CharType>
+                struct add_ftime {
+
+                    std::basic_string<CharType> ftime;
+
+                    void apply(std::basic_ios<CharType> &ios) const
+                    {
+                        ios_info::get(ios).date_time_pattern(ftime);
+                        as::strftime(ios);
+                    }
+
+                };
+
+                template<typename CharType>
+                std::basic_ostream<CharType> &operator<<(std::basic_ostream<CharType> &out,add_ftime<CharType> const &fmt)
+                {
+                    fmt.apply(out);
+                    return out;
+                }
+                
+                template<typename CharType>
+                std::basic_istream<CharType> &operator>>(std::basic_istream<CharType> &in,add_ftime<CharType> const &fmt)
+                {
+                    fmt.apply(in);
+                    return in;
+                }
+
+            }
+            /// \endcond 
+
+            ///
+            /// Set strftime like formatting string
+            ///
+            /// Please note, formatting flags are very similar but not exactly the same as flags for C function strftime.
+            /// Differences: some flags as "%e" do not add blanks to fill text up to two spaces, not all flags supported.
+            ///
+            /// Flags:
+            /// -   "%a" -- Abbreviated  weekday (Sun.)
+            /// -   "%A" -- Full weekday (Sunday)
+            /// -   "%b" -- Abbreviated month (Jan.)
+            /// -   "%B" -- Full month (January)
+            /// -   "%c" -- Locale date-time format. **Note:** prefer using "as::datetime"
+            /// -   "%d" -- Day of Month [01,31]
+            /// -   "%e" -- Day of Month [1,31]
+            /// -   "%h" -- Same as "%b"
+            /// -   "%H" -- 24 clock hour [00,23]
+            /// -   "%I" -- 12 clock hour [01,12]
+            /// -   "%j" -- Day of year [1,366]
+            /// -   "%m" -- Month [01,12]
+            /// -   "%M" -- Minute [00,59]
+            /// -   "%n" -- New Line
+            /// -   "%p" -- AM/PM in locale representation
+            /// -   "%r" -- Time with AM/PM, same as "%I:%M:%S %p"
+            /// -   "%R" -- Same as "%H:%M"
+            /// -   "%S" -- Second [00,61]
+            /// -   "%t" -- Tab character
+            /// -   "%T" -- Same as "%H:%M:%S"
+            /// -   "%x" -- Local date representation. **Note:** prefer using "as::date"
+            /// -   "%X" -- Local time representation. **Note:** prefer using "as::time"
+            /// -   "%y" -- Year [00,99]
+            /// -   "%Y" -- 4 digits year. (2009)
+            /// -   "%Z" -- Time Zone
+            /// -   "%%" -- Percent symbol
+            ///
+
+
+            template<typename CharType>
+            #ifdef BOOST_LOCALE_DOXYGEN
+            unspecified_type
+            #else
+            details::add_ftime<CharType> 
+            #endif
+            ftime(std::basic_string<CharType> const &format)
+            {
+                details::add_ftime<CharType> fmt;
+                fmt.ftime=format;
+                return fmt;
+            }
+
+            ///
+            /// See ftime(std::basic_string<CharType> const &format)
+            ///
+            template<typename CharType>
+            #ifdef BOOST_LOCALE_DOXYGEN
+            unspecified_type
+            #else
+            details::add_ftime<CharType> 
+            #endif
+            ftime(CharType const *format)
+            {
+                details::add_ftime<CharType> fmt;
+                fmt.ftime=format;
+                return fmt;
+            }
+
+            /// \cond INTERNAL
+            namespace details {
+                struct set_timezone {
+                    std::string id;
+                };
+                template<typename CharType>
+                std::basic_ostream<CharType> &operator<<(std::basic_ostream<CharType> &out,set_timezone const &fmt)
+                {
+                    ios_info::get(out).time_zone(fmt.id);
+                    return out;
+                }
+                
+                template<typename CharType>
+                std::basic_istream<CharType> &operator>>(std::basic_istream<CharType> &in,set_timezone const &fmt)
+                {
+                    ios_info::get(in).time_zone(fmt.id);
+                    return in;
+                }
+            }
+            /// \endcond
+            
+            ///
+            /// Set GMT time zone to stream
+            /// 
+            inline std::ios_base &gmt(std::ios_base &ios)
+            {
+                ios_info::get(ios).time_zone("GMT");
+                return ios;
+            }
+
+            ///
+            /// Set local time zone to stream
+            ///
+            inline std::ios_base &local_time(std::ios_base &ios)
+            {
+                ios_info::get(ios).time_zone(time_zone::global());
+                return ios;
+            }
+
+            ///
+            /// Set time zone using \a id
+            ///
+            inline 
+            #ifdef BOOST_LOCALE_DOXYGEN
+            unspecified_type
+            #else
+            details::set_timezone 
+            #endif
+            time_zone(char const *id) 
+            {
+                details::set_timezone tz;
+                tz.id=id;
+                return tz;
+            }
+
+            ///
+            /// Set time zone using \a id
+            ///
+            inline 
+            #ifdef BOOST_LOCALE_DOXYGEN
+            unspecified_type
+            #else
+            details::set_timezone 
+            #endif            
+            time_zone(std::string const &id) 
+            {
+                details::set_timezone tz;
+                tz.id=id;
+                return tz;
+            }
+
+
+        ///
+        /// @}
+        ///
+
+        } // as manipulators
+        
+    } // locale
+} // boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+
+#endif
+// vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4