Boost.Locale: boost/locale/formatting.hpp Source File

# Boost C++ Libraries

...one of the most highly regarded and expertly designed C++ library projects in the world. — Herb Sutter and Andrei Alexandrescu, C++ Coding Standards

- Main Page
- Modules
- Namespaces
- Classes
- Files
- Examples

- File List

# boost/locale/formatting.hpp

    00001 //
    00002 //  Copyright (c) 2009-2011 Artyom Beilis (Tonkikh)
    00003 //
    00004 //  Distributed under the Boost Software License, Version 1.0. (See
    00005 //  accompanying file LICENSE_1_0.txt or copy at
    00006 //  http://www.boost.org/LICENSE_1_0.txt)
    00007 //
    00008 #ifndef BOOST_LOCALE_FORMATTING_HPP_INCLUDED
    00009 #define BOOST_LOCALE_FORMATTING_HPP_INCLUDED
    00010
    00011 #include <boost/locale/config.hpp>
    00012 #ifdef BOOST_MSVC
    00013 #  pragma warning(push)
    00014 #  pragma warning(disable : 4275 4251 4231 4660)
    00015 #endif
    00016 #include <boost/cstdint.hpp>
    00017 #include <boost/locale/time_zone.hpp>
    00018 #include <ostream>
    00019 #include <istream>
    00020 #include <string>
    00021 #include <string.h>
    00022 #include <typeinfo>
    00023
    00024 namespace boost {
    00025     namespace locale {
    00030         namespace flags {
    00035             typedef enum {
    00036                 posix               = 0,
    00037                 number              = 1,
    00038                 currency            = 2,
    00039                 percent             = 3,
    00040                 date                = 4,
    00041                 time                = 5,
    00042                 datetime            = 6,
    00043                 strftime            = 7,
    00044                 spellout            = 8,
    00045                 ordinal             = 9,
    00046
    00047                 display_flags_mask  = 31,
    00048
    00049                 currency_default    = 0 << 5,
    00050                 currency_iso        = 1 << 5,
    00051                 currency_national   = 2 << 5,
    00052
    00053                 currency_flags_mask = 3 << 5,
    00054
    00055                 time_default        = 0 << 7,
    00056                 time_short          = 1 << 7,
    00057                 time_medium         = 2 << 7,
    00058                 time_long           = 3 << 7,
    00059                 time_full           = 4 << 7,
    00060                 time_flags_mask     = 7 << 7,
    00061
    00062                 date_default        = 0 << 10,
    00063                 date_short          = 1 << 10,
    00064                 date_medium         = 2 << 10,
    00065                 date_long           = 3 << 10,
    00066                 date_full           = 4 << 10,
    00067                 date_flags_mask     = 7 << 10,
    00068
    00069                 datetime_flags_mask = date_flags_mask | time_flags_mask
    00070
    00071             } display_flags_type;
    00072
    00077             typedef enum {
    00078                 datetime_pattern,
    00079                 time_zone_id
    00080             } pattern_type;
    00081
    00085             typedef enum {
    00086                 domain_id
    00087             } value_type;
    00088
    00089
    00090         } // flags
    00091
    00098         class BOOST_LOCALE_DECL ios_info {
    00099         public:
    00100
    00102
    00103             ios_info();
    00104             ios_info(ios_info const &);
    00105             ios_info const &operator=(ios_info const &);
    00106             ~ios_info();
    00107
    00109
    00113             static ios_info &get(std::ios_base &ios);
    00114
    00118             void display_flags(uint64_t flags);
    00119
    00123             void currency_flags(uint64_t flags);
    00124
    00128             void date_flags(uint64_t flags);
    00129
    00133             void time_flags(uint64_t flags);
    00134
    00138             void datetime_flags(uint64_t flags);
    00139
    00143             void domain_id(int);
    00144
    00148             void time_zone(std::string const &);
    00149
    00150
    00154             template<typename CharType>
    00155             void date_time_pattern(std::basic_string<CharType> const &str)
    00156             {
    00157                 string_set &s = date_time_pattern_set();
    00158                 s.set<CharType>(str.c_str());
    00159             }
    00160
    00161
    00165             uint64_t display_flags() const;
    00166
    00170             uint64_t currency_flags() const;
    00171
    00172
    00176             uint64_t date_flags() const;
    00177
    00181             uint64_t time_flags() const;
    00182
    00186             uint64_t datetime_flags() const;
    00187
    00191             int domain_id() const;
    00192
    00196             std::string time_zone() const;
    00197
    00201             template<typename CharType>
    00202             std::basic_string<CharType> date_time_pattern() const
    00203             {
    00204                 string_set const &s = date_time_pattern_set();
    00205                 return s.get<CharType>();
    00206             }
    00207
    00209             void on_imbue();
    00211
    00212         private:
    00213
    00214             class string_set;
    00215
    00216             string_set const &date_time_pattern_set() const;
    00217             string_set &date_time_pattern_set();
    00218
    00219             class BOOST_LOCALE_DECL string_set {
    00220             public:
    00221                 string_set();
    00222                 ~string_set();
    00223                 string_set(string_set const &other);
    00224                 string_set const &operator=(string_set const &other);
    00225                 void swap(string_set &other);
    00226
    00227                 template<typename Char>
    00228                 void set(Char const *s)
    00229                 {
    00230                     delete [] ptr;
    00231                     ptr = 0;
    00232                     type=&typeid(Char);
    00233                     Char const *end = s;
    00234                     while(*end!=0) end++;
    00235                     // if ptr = 0 it does not matter what is value of size
    00236                     size = sizeof(Char)*(end - s+1);
    00237                     ptr = new char[size];
    00238                     memcpy(ptr,s,size);
    00239                 }
    00240
    00241                 template<typename Char>
    00242                 std::basic_string<Char> get() const
    00243                 {
    00244                     if(type==0 || *type!=typeid(Char))
    00245                         throw std::bad_cast();
    00246                     std::basic_string<Char> result = reinterpret_cast<Char const *>(ptr);
    00247                     return result;
    00248                 }
    00249
    00250             private:
    00251                 std::type_info const *type;
    00252                 size_t size;
    00253                 char *ptr;
    00254             };
    00255
    00256             uint64_t flags_;
    00257             int domain_id_;
    00258             std::string time_zone_;
    00259             string_set datetime_;
    00260
    00261             struct data;
    00262             data *d;
    00263
    00264         };
    00265
    00266
    00270         namespace as {
    00276
    00281
    00282             inline std::ios_base & posix(std::ios_base & ios)
    00283             {
    00284                 ios_info::get(ios).display_flags(flags::posix);
    00285                 return ios;
    00286             }
    00287
    00292             inline std::ios_base & number(std::ios_base & ios)
    00293             {
    00294                 ios_info::get(ios).display_flags(flags::number);
    00295                 return ios;
    00296             }
    00297
    00301             inline std::ios_base & currency(std::ios_base & ios)
    00302             {
    00303                 ios_info::get(ios).display_flags(flags::currency);
    00304                 return ios;
    00305             }
    00306
    00310             inline std::ios_base & percent(std::ios_base & ios)
    00311             {
    00312                 ios_info::get(ios).display_flags(flags::percent);
    00313                 return ios;
    00314             }
    00315
    00319             inline std::ios_base & date(std::ios_base & ios)
    00320             {
    00321                 ios_info::get(ios).display_flags(flags::date);
    00322                 return ios;
    00323             }
    00324
    00328             inline std::ios_base & time(std::ios_base & ios)
    00329             {
    00330                 ios_info::get(ios).display_flags(flags::time);
    00331                 return ios;
    00332             }
    00333
    00337             inline std::ios_base & datetime(std::ios_base & ios)
    00338             {
    00339                 ios_info::get(ios).display_flags(flags::datetime);
    00340                 return ios;
    00341             }
    00342
    00347             inline std::ios_base & strftime(std::ios_base & ios)
    00348             {
    00349                 ios_info::get(ios).display_flags(flags::strftime);
    00350                 return ios;
    00351             }
    00352
    00356             inline std::ios_base & spellout(std::ios_base & ios)
    00357             {
    00358                 ios_info::get(ios).display_flags(flags::spellout);
    00359                 return ios;
    00360             }
    00361
    00365             inline std::ios_base & ordinal(std::ios_base & ios)
    00366             {
    00367                 ios_info::get(ios).display_flags(flags::ordinal);
    00368                 return ios;
    00369             }
    00370
    00374             inline std::ios_base & currency_default(std::ios_base & ios)
    00375             {
    00376                 ios_info::get(ios).currency_flags(flags::currency_default);
    00377                 return ios;
    00378             }
    00379
    00383             inline std::ios_base & currency_iso(std::ios_base & ios)
    00384             {
    00385                 ios_info::get(ios).currency_flags(flags::currency_iso);
    00386                 return ios;
    00387             }
    00388
    00392             inline std::ios_base & currency_national(std::ios_base & ios)
    00393             {
    00394                 ios_info::get(ios).currency_flags(flags::currency_national);
    00395                 return ios;
    00396             }
    00397
    00401             inline std::ios_base & time_default(std::ios_base & ios)
    00402             {
    00403                 ios_info::get(ios).time_flags(flags::time_default);
    00404                 return ios;
    00405             }
    00406
    00410             inline std::ios_base & time_short(std::ios_base & ios)
    00411             {
    00412                 ios_info::get(ios).time_flags(flags::time_short);
    00413                 return ios;
    00414             }
    00415
    00419             inline std::ios_base & time_medium(std::ios_base & ios)
    00420             {
    00421                 ios_info::get(ios).time_flags(flags::time_medium);
    00422                 return ios;
    00423             }
    00424
    00428             inline std::ios_base & time_long(std::ios_base & ios)
    00429             {
    00430                 ios_info::get(ios).time_flags(flags::time_long);
    00431                 return ios;
    00432             }
    00433
    00437             inline std::ios_base & time_full(std::ios_base & ios)
    00438             {
    00439                 ios_info::get(ios).time_flags(flags::time_full);
    00440                 return ios;
    00441             }
    00442
    00446             inline std::ios_base & date_default(std::ios_base & ios)
    00447             {
    00448                 ios_info::get(ios).date_flags(flags::date_default);
    00449                 return ios;
    00450             }
    00451
    00455             inline std::ios_base & date_short(std::ios_base & ios)
    00456             {
    00457                 ios_info::get(ios).date_flags(flags::date_short);
    00458                 return ios;
    00459             }
    00460
    00464             inline std::ios_base & date_medium(std::ios_base & ios)
    00465             {
    00466                 ios_info::get(ios).date_flags(flags::date_medium);
    00467                 return ios;
    00468             }
    00469
    00473             inline std::ios_base & date_long(std::ios_base & ios)
    00474             {
    00475                 ios_info::get(ios).date_flags(flags::date_long);
    00476                 return ios;
    00477             }
    00478
    00482             inline std::ios_base & date_full(std::ios_base & ios)
    00483             {
    00484                 ios_info::get(ios).date_flags(flags::date_full);
    00485                 return ios;
    00486             }
    00487
    00488
    00490             namespace details {
    00491                 template<typename CharType>
    00492                 struct add_ftime {
    00493
    00494                     std::basic_string<CharType> ftime;
    00495
    00496                     void apply(std::basic_ios<CharType> &ios) const
    00497                     {
    00498                         ios_info::get(ios).date_time_pattern(ftime);
    00499                         as::strftime(ios);
    00500                     }
    00501
    00502                 };
    00503
    00504                 template<typename CharType>
    00505                 std::basic_ostream<CharType> &operator<<(std::basic_ostream<CharType> &out,add_ftime<CharType> const &fmt)
    00506                 {
    00507                     fmt.apply(out);
    00508                     return out;
    00509                 }
    00510
    00511                 template<typename CharType>
    00512                 std::basic_istream<CharType> &operator>>(std::basic_istream<CharType> &in,add_ftime<CharType> const &fmt)
    00513                 {
    00514                     fmt.apply(in);
    00515                     return in;
    00516                 }
    00517
    00518             }
    00520
    00555
    00556
    00557             template<typename CharType>
    00558             #ifdef BOOST_LOCALE_DOXYGEN
    00559             unspecified_type
    00560             #else
    00561             details::add_ftime<CharType>
    00562             #endif
    00563             ftime(std::basic_string<CharType> const &format)
    00564             {
    00565                 details::add_ftime<CharType> fmt;
    00566                 fmt.ftime=format;
    00567                 return fmt;
    00568             }
    00569
    00573             template<typename CharType>
    00574             #ifdef BOOST_LOCALE_DOXYGEN
    00575             unspecified_type
    00576             #else
    00577             details::add_ftime<CharType>
    00578             #endif
    00579             ftime(CharType const *format)
    00580             {
    00581                 details::add_ftime<CharType> fmt;
    00582                 fmt.ftime=format;
    00583                 return fmt;
    00584             }
    00585
    00587             namespace details {
    00588                 struct set_timezone {
    00589                     std::string id;
    00590                 };
    00591                 template<typename CharType>
    00592                 std::basic_ostream<CharType> &operator<<(std::basic_ostream<CharType> &out,set_timezone const &fmt)
    00593                 {
    00594                     ios_info::get(out).time_zone(fmt.id);
    00595                     return out;
    00596                 }
    00597
    00598                 template<typename CharType>
    00599                 std::basic_istream<CharType> &operator>>(std::basic_istream<CharType> &in,set_timezone const &fmt)
    00600                 {
    00601                     ios_info::get(in).time_zone(fmt.id);
    00602                     return in;
    00603                 }
    00604             }
    00606
    00610             inline std::ios_base &gmt(std::ios_base &ios)
    00611             {
    00612                 ios_info::get(ios).time_zone("GMT");
    00613                 return ios;
    00614             }
    00615
    00619             inline std::ios_base &local_time(std::ios_base &ios)
    00620             {
    00621                 ios_info::get(ios).time_zone(time_zone::global());
    00622                 return ios;
    00623             }
    00624
    00628             inline
    00629             #ifdef BOOST_LOCALE_DOXYGEN
    00630             unspecified_type
    00631             #else
    00632             details::set_timezone
    00633             #endif
    00634             time_zone(char const *id)
    00635             {
    00636                 details::set_timezone tz;
    00637                 tz.id=id;
    00638                 return tz;
    00639             }
    00640
    00644             inline
    00645             #ifdef BOOST_LOCALE_DOXYGEN
    00646             unspecified_type
    00647             #else
    00648             details::set_timezone
    00649             #endif
    00650             time_zone(std::string const &id)
    00651             {
    00652                 details::set_timezone tz;
    00653                 tz.id=id;
    00654                 return tz;
    00655             }
    00656
    00657
    00661
    00662         } // as manipulators
    00663
    00664     } // locale
    00665 } // boost
    00666
    00667 #ifdef BOOST_MSVC
    00668 #pragma warning(pop)
    00669 #endif
    00670
    00671
    00672 #endif
    00673 // vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4