| // |
| // 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 |
