Ye_Ol_Pi_Shack
/
CppCMS
2
0
Fork 0
Code Issues 0 Pull Requests 0 Releases 1 Wiki Activity
ChipMaster's trial hacks on C++CMS starting with v1.2.1. Not sure I'll follow on with the v2 since it looks to be breaking and mostly frivolous.
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1248 Commits
2 Branches
13 MiB
 
 
 
 
 
 
Tree: d1de6e5074
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'd1de6e5074'
${ noResults }
CppCMS/booster/booster/locale/generator.h

236 lines
9.3 KiB
Raw Blame History 

  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 BOOSTER_LOCALE_GENERATOR_HPP

  9. #define BOOSTER_LOCALE_GENERATOR_HPP

  10. #include <booster/config.h>

  11. #include <booster/cstdint.h>

  12. #ifdef BOOSTER_MSVC

  13. #  pragma warning(push)

  14. #  pragma warning(disable : 4275 4251 4231 4660)

  15. #endif

  16. #include <string>

  17. #include <locale>

  18. #include <booster/auto_ptr_inc.h>

  19. 

  20. namespace booster {

  21. 

  22.     template<typename Type>

  23.     class shared_ptr;

  24. 

  25.     ///

  26.     /// \brief This is the main namespace that encloses all localization classes 

  27.     ///

  28.     namespace locale {

  29. 

  30.         class localization_backend;

  31.         class localization_backend_manager;

  32. 

  33.         static const uint32_t nochar_facet    = 0;        ///< Unspecified character category for character independent facets

  34.         static const uint32_t char_facet      = 1 << 0;   ///< 8-bit character facets

  35.         static const uint32_t wchar_t_facet   = 1 << 1;   ///< wide character facets

  36.         static const uint32_t char16_t_facet  = 1 << 2;   ///< C++0x char16_t facets

  37.         static const uint32_t char32_t_facet  = 1 << 3;   ///< C++0x char32_t facets

  38. 

  39.         static const uint32_t character_first_facet = char_facet;  ///< First facet specific for character type

  40.         static const uint32_t character_last_facet = char32_t_facet; ///< Last facet specific for character type

  41.         static const uint32_t all_characters = 0xFFFF;     ///< Special mask -- generate all

  42.         

  43.         typedef uint32_t character_facet_type; ///<type that specifies the character type that locales can be generated for

  44. 

  45.         static const uint32_t     convert_facet   = 1 << 0;   ///< Generate conversion facets

  46.         static const uint32_t     collation_facet = 1 << 1;   ///< Generate collation facets

  47.         static const uint32_t     formatting_facet= 1 << 2;   ///< Generate numbers, currency, date-time formatting facets

  48.         static const uint32_t     parsing_facet   = 1 << 3;   ///< Generate numbers, currency, date-time formatting facets

  49.         static const uint32_t     message_facet   = 1 << 4;   ///< Generate message facets

  50.         static const uint32_t     codepage_facet  = 1 << 5;   ///< Generate character set conversion facets (derived from std::codecvt)

  51.         static const uint32_t     boundary_facet  = 1 << 6;   ///< Generate boundary analysis facet

  52.             

  53.         static const uint32_t     per_character_facet_first = convert_facet; ///< First facet specific for character

  54.         static const uint32_t     per_character_facet_last = boundary_facet; ///< Last facet specific for character

  55. 

  56.         static const uint32_t     calendar_facet  = 1 << 16;   ///< Generate boundary analysis facet

  57.         static const uint32_t     information_facet = 1 << 17;   ///< Generate general locale information facet

  58. 

  59.         static const uint32_t    non_character_facet_first = calendar_facet; ///< First character independent facet 

  60.         static const uint32_t    non_character_facet_last = information_facet;///< Last character independent facet 

  61. 

  62.             

  63.         static const uint32_t    all_categories  = 0xFFFFFFFFu;   ///< Generate all of them

  64.         

  65.         typedef uint32_t locale_category_type; ///< a type used for more fine grained generation of facets

  66. 

  67.         ///

  68.         /// \brief the major class used for locale generation

  69.         ///

  70.         /// This class is used for specification of all parameters required for locale generation and

  71.         /// caching. This class const member functions are thread safe if locale class implementation is thread safe.

  72.         ///

  73. 

  74.         class BOOSTER_API generator {

  75.         public:

  76. 

  77.             ///

  78.             /// Create new generator using global localization_backend_manager 

  79.             ///

  80.             generator();

  81.             ///

  82.             /// Create new generator using specific localization_backend_manager 

  83.             ///

  84.             generator(localization_backend_manager const &);

  85. 

  86.             ~generator();

  87. 

  88.             ///

  89.             /// Set types of facets that should be generated, default all

  90.             ///

  91.             void categories(locale_category_type cats);

  92.             ///

  93.             /// Get types of facets that should be generated, default all

  94.             ///

  95.             locale_category_type categories() const;

  96.             

  97.             ///

  98.             /// Set the characters type for which the facets should be generated, default all supported

  99.             ///

  100.             void characters(character_facet_type chars);

  101.             ///

  102.             /// Get the characters type for which the facets should be generated, default all supported

  103.             ///

  104.             character_facet_type characters() const;

  105. 

  106.             ///

  107.             /// Add a new domain of messages that would be generated. It should be set in order to enable

  108.             /// messages support.

  109.             ///

  110.             /// Messages domain has following format: "name" or "name/encoding"

  111.             /// where name is the base name of the "mo" file where the catalog is stored

  112.             /// without ".mo" extension. For example for file \c /usr/share/locale/he/LC_MESSAGES/blog.mo

  113.             /// it would be \c blog.

  114.             ///

  115.             /// You can optionally specify the encoding of the keys in the sources by adding "/encoding_name"

  116.             /// For example blog/cp1255.

  117.             ///

  118.             /// If not defined all keys are assumed to be UTF-8 encoded.

  119.             ///

  120.             /// \note When you select a domain for the program using dgettext or message API, you

  121.             /// do not specify the encoding part. So for example if the provided

  122.             /// domain name was "blog/windows-1255" then for translation

  123.             /// you should use dgettext("blog","Hello")

  124.             ///

  125.             ///

  126.             void add_messages_domain(std::string const &domain);

  127.             ///

  128.             /// Set default message domain. If this member was not called, the first added messages domain is used.

  129.             /// If the domain \a domain is not added yet it is added.

  130.             ///

  131.             void set_default_messages_domain(std::string const &domain);

  132. 

  133.             ///

  134.             /// Remove all added domains from the list

  135.             ///

  136.             void clear_domains();

  137. 

  138.             ///

  139.             /// Add a search path where dictionaries are looked in.

  140.             ///

  141.             /// \note

  142.             ///

  143.             /// - Under the Windows platform the path is treated as a path in the locale's encoding so

  144.             ///   if you create locale "en_US.windows-1251" then path would be treated as cp1255,

  145.             ///   and if it is en_US.UTF-8 it is treated as UTF-8. File name is always opened with 

  146.             ///   a wide file name as wide file names are the native file name on Windows.

  147.             ///

  148.             /// - Under POSIX platforms all paths passed as-is regardless of encoding as narrow

  149.             ///   encodings are the native encodings for POSIX platforms.

  150.             ///   

  151.             /// 

  152.             void add_messages_path(std::string const &path);

  153. 

  154.             ///

  155.             /// Remove all added paths

  156.             ///

  157.             void clear_paths();

  158. 

  159.             ///

  160.             /// Remove all cached locales

  161.             ///

  162.             void clear_cache();

  163. 

  164.             ///

  165.             /// Turn locale caching ON

  166.             ///

  167.             void locale_cache_enabled(bool on);

  168. 

  169.             ///

  170.             /// Get locale cache option

  171.             ///

  172.             bool locale_cache_enabled() const;

  173. 

  174.             ///

  175.             /// Check if by default ANSI encoding is selected or UTF-8 onces. The default is false.

  176.             ///

  177.             bool use_ansi_encoding() const;

  178. 

  179.             ///

  180.             /// Select ANSI encodings as default system encoding rather then UTF-8 by default

  181.             /// under Windows.

  182.             ///

  183.             /// The default is the most portable and most powerful encoding, UTF-8, but the user

  184.             /// can select "system" one if dealing with legacy applications

  185.             ///

  186.             void use_ansi_encoding(bool enc);

  187. 

  188.             ///

  189.             /// Generate a locale with id \a id

  190.             ///

  191.             std::locale generate(std::string const &id) const;

  192.             ///

  193.             /// Generate a locale with id \a id. Use \a base as a locale to which all facets are added,

  194.             /// instead of std::locale::classic().

  195.             ///

  196.             std::locale generate(std::locale const &base,std::string const &id) const;

  197.             ///

  198.             /// Shortcut to generate(id)

  199.             ///

  200.             std::locale operator()(std::string const &id) const

  201.             {

  202.                 return generate(id);

  203.             }

  204.             

  205.             ///

  206.             /// Set backend specific option

  207.             ///

  208.             void set_option(std::string const &name,std::string const &value);

  209. 

  210.             ///

  211.             /// Clear backend specific options

  212.             ///

  213.             void clear_options();

  214. 

  215.         private:

  216. 

  217.             void set_all_options(shared_ptr<localization_backend> backend,std::string const &id) const;

  218. 

  219.             generator(generator const &);

  220.             void operator=(generator const &);

  221. 

  222.             struct data;

  223.             std::auto_ptr<data> d;

  224.         };

  225. 

  226.     }

  227. }

  228. #ifdef BOOSTER_MSVC

  229. #pragma warning(pop)

  230. #endif

  231. 

  232. 

  233. #endif

  234. // vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4