ceph/src/boost/boost/locale/generator.hpp

   1 //
   2 //  Copyright (c) 2009-2011 Artyom Beilis (Tonkikh)
   3 //
   4 //  Distributed under the Boost Software License, Version 1.0. (See
   5 //  accompanying file LICENSE_1_0.txt or copy at
   6 //  http://www.boost.org/LICENSE_1_0.txt)
   7 //
   8 #ifndef BOOST_LOCALE_GENERATOR_HPP
   9 #define BOOST_LOCALE_GENERATOR_HPP
  10 #include <boost/locale/config.hpp>
  11 #include <boost/cstdint.hpp>
  12 #ifdef BOOST_MSVC
  13 #  pragma warning(push)
  14 #  pragma warning(disable : 4275 4251 4231 4660)
  15 #endif
  16 #include <string>
  17 #include <locale>
  18 #include <memory>
  19 #include <boost/locale/hold_ptr.hpp>
  20
  21 namespace boost {
  22
  23     template<typename Type>
  24     class shared_ptr;
  25
  26     ///
  27     /// \brief This is the main namespace that encloses all localization classes
  28     ///
  29     namespace locale {
  30
  31         class localization_backend;
  32         class localization_backend_manager;
  33
  34         static const uint32_t nochar_facet    = 0;        ///< Unspecified character category for character independent facets
  35         static const uint32_t char_facet      = 1 << 0;   ///< 8-bit character facets
  36         static const uint32_t wchar_t_facet   = 1 << 1;   ///< wide character facets
  37         static const uint32_t char16_t_facet  = 1 << 2;   ///< C++0x char16_t facets
  38         static const uint32_t char32_t_facet  = 1 << 3;   ///< C++0x char32_t facets
  39
  40         static const uint32_t character_first_facet = char_facet;  ///< First facet specific for character type
  41         static const uint32_t character_last_facet = char32_t_facet; ///< Last facet specific for character type
  42         static const uint32_t all_characters = 0xFFFF;     ///< Special mask -- generate all
  43
  44         typedef uint32_t character_facet_type; ///<type that specifies the character type that locales can be generated for
  45
  46         static const uint32_t     convert_facet   = 1 << 0;   ///< Generate conversion facets
  47         static const uint32_t     collation_facet = 1 << 1;   ///< Generate collation facets
  48         static const uint32_t     formatting_facet= 1 << 2;   ///< Generate numbers, currency, date-time formatting facets
  49         static const uint32_t     parsing_facet   = 1 << 3;   ///< Generate numbers, currency, date-time formatting facets
  50         static const uint32_t     message_facet   = 1 << 4;   ///< Generate message facets
  51         static const uint32_t     codepage_facet  = 1 << 5;   ///< Generate character set conversion facets (derived from std::codecvt)
  52         static const uint32_t     boundary_facet  = 1 << 6;   ///< Generate boundary analysis facet
  53
  54         static const uint32_t     per_character_facet_first = convert_facet; ///< First facet specific for character
  55         static const uint32_t     per_character_facet_last = boundary_facet; ///< Last facet specific for character
  56
  57         static const uint32_t     calendar_facet  = 1 << 16;   ///< Generate boundary analysis facet
  58         static const uint32_t     information_facet = 1 << 17;   ///< Generate general locale information facet
  59
  60         static const uint32_t    non_character_facet_first = calendar_facet; ///< First character independent facet
  61         static const uint32_t    non_character_facet_last = information_facet;///< Last character independent facet
  62
  63
  64         static const uint32_t    all_categories  = 0xFFFFFFFFu;   ///< Generate all of them
  65
  66         typedef uint32_t locale_category_type; ///< a type used for more fine grained generation of facets
  67
  68         ///
  69         /// \brief the major class used for locale generation
  70         ///
  71         /// This class is used for specification of all parameters required for locale generation and
  72         /// caching. This class const member functions are thread safe if locale class implementation is thread safe.
  73         ///
  74
  75         class BOOST_LOCALE_DECL generator {
  76         public:
  77
  78             ///
  79             /// Create new generator using global localization_backend_manager
  80             ///
  81             generator();
  82             ///
  83             /// Create new generator using specific localization_backend_manager
  84             ///
  85             generator(localization_backend_manager const &);
  86
  87             ~generator();
  88
  89             ///
  90             /// Set types of facets that should be generated, default all
  91             ///
  92             void categories(locale_category_type cats);
  93             ///
  94             /// Get types of facets that should be generated, default all
  95             ///
  96             locale_category_type categories() const;
  97
  98             ///
  99             /// Set the characters type for which the facets should be generated, default all supported
 100             ///
 101             void characters(character_facet_type chars);
 102             ///
 103             /// Get the characters type for which the facets should be generated, default all supported
 104             ///
 105             character_facet_type characters() const;
 106
 107             ///
 108             /// Add a new domain of messages that would be generated. It should be set in order to enable
 109             /// messages support.
 110             ///
 111             /// Messages domain has following format: "name" or "name/encoding"
 112             /// where name is the base name of the "mo" file where the catalog is stored
 113             /// without ".mo" extension. For example for file \c /usr/share/locale/he/LC_MESSAGES/blog.mo
 114             /// it would be \c blog.
 115             ///
 116             /// You can optionally specify the encoding of the keys in the sources by adding "/encoding_name"
 117             /// For example blog/cp1255.
 118             ///
 119             /// If not defined all keys are assumed to be UTF-8 encoded.
 120             ///
 121             /// \note When you select a domain for the program using dgettext or message API, you
 122             /// do not specify the encoding part. So for example if the provided
 123             /// domain name was "blog/windows-1255" then for translation
 124             /// you should use dgettext("blog","Hello")
 125             ///
 126             ///
 127             void add_messages_domain(std::string const &domain);
 128             ///
 129             /// Set default message domain. If this member was not called, the first added messages domain is used.
 130             /// If the domain \a domain is not added yet it is added.
 131             ///
 132             void set_default_messages_domain(std::string const &domain);
 133
 134             ///
 135             /// Remove all added domains from the list
 136             ///
 137             void clear_domains();
 138
 139             ///
 140             /// Add a search path where dictionaries are looked in.
 141             ///
 142             /// \note
 143             ///
 144             /// - Under the Windows platform the path is treated as a path in the locale's encoding so
 145             ///   if you create locale "en_US.windows-1251" then path would be treated as cp1255,
 146             ///   and if it is en_US.UTF-8 it is treated as UTF-8. File name is always opened with
 147             ///   a wide file name as wide file names are the native file name on Windows.
 148             ///
 149             /// - Under POSIX platforms all paths passed as-is regardless of encoding as narrow
 150             ///   encodings are the native encodings for POSIX platforms.
 151             ///
 152             ///
 153             void add_messages_path(std::string const &path);
 154
 155             ///
 156             /// Remove all added paths
 157             ///
 158             void clear_paths();
 159
 160             ///
 161             /// Remove all cached locales
 162             ///
 163             void clear_cache();
 164
 165             ///
 166             /// Turn locale caching ON
 167             ///
 168             void locale_cache_enabled(bool on);
 169
 170             ///
 171             /// Get locale cache option
 172             ///
 173             bool locale_cache_enabled() const;
 174
 175             ///
 176             /// Check if by default ANSI encoding is selected or UTF-8 onces. The default is false.
 177             ///
 178             bool use_ansi_encoding() const;
 179
 180             ///
 181             /// Select ANSI encodings as default system encoding rather then UTF-8 by default
 182             /// under Windows.
 183             ///
 184             /// The default is the most portable and most powerful encoding, UTF-8, but the user
 185             /// can select "system" one if dealing with legacy applications
 186             ///
 187             void use_ansi_encoding(bool enc);
 188
 189             ///
 190             /// Generate a locale with id \a id
 191             ///
 192             std::locale generate(std::string const &id) const;
 193             ///
 194             /// Generate a locale with id \a id. Use \a base as a locale to which all facets are added,
 195             /// instead of std::locale::classic().
 196             ///
 197             std::locale generate(std::locale const &base,std::string const &id) const;
 198             ///
 199             /// Shortcut to generate(id)
 200             ///
 201             std::locale operator()(std::string const &id) const
 202             {
 203                 return generate(id);
 204             }
 205
 206             ///
 207             /// Set backend specific option
 208             ///
 209             void set_option(std::string const &name,std::string const &value);
 210
 211             ///
 212             /// Clear backend specific options
 213             ///
 214             void clear_options();
 215
 216         private:
 217
 218             void set_all_options(shared_ptr<localization_backend> backend,std::string const &id) const;
 219
 220             generator(generator const &);
 221             void operator=(generator const &);
 222
 223             struct data;
 224             hold_ptr<data> d;
 225         };
 226
 227     }
 228 }
 229 #ifdef BOOST_MSVC
 230 #pragma warning(pop)
 231 #endif
 232
 233
 234 #endif
 235 // vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4
 236