Rename use_facet to get_facet

Author: robhz786

docs/howto_add_printable_types.adoc

@@ -36,7 +36,7 @@ http://www.boost.org/LICENSE_1_0.txt)
 
 :join:            <<quick_reference#join,join>>
 :Facet:           <<strf_hpp#Facet,Facet>>
-:use_facet:       <<strf_hpp#use_facet,use_facet>>
+:get_facet:       <<strf_hpp#get_facet,get_facet>>
 :facets_pack:     <<strf_hpp#facets_pack,facets_pack>>
 :tag:             <<strf_hpp#tag,tag>>
 
@@ -602,18 +602,18 @@ Then, instead of calling `get_complex_form()`,
 
 [source,cpp,subs=normal]
 ----
-complex_form form = strf::{use_facet}<complex_form_c, std::complex<FloatT>>(facets);
+complex_form form = strf::{get_facet}<complex_form_c, std::complex<FloatT>>(facets);
 ----
 
-`use_facet` is used to extract a facet object from a `{facets_pack}` object.
+`get_facet` is used to extract a facet object from a `{facets_pack}` object.
 The first template parameter is the facet category.
 The second is the usually printable type and it only has effect when there is
 any <<tutorial#constrained_facets,constrained facets>> of the given category
 in the the `{facets_pack}` object. The effect is that
-`{use_facet}` only returns the value inside a constrained facet when
+`{get_facet}` only returns the value inside a constrained facet when
 `Filter<Tag>::value` is `true` ,
 where `Filter` is the template parameter of the constrained facet, and `Tag`
-is the second template parameter used in `{use_facet}`
+is the second template parameter used in `{get_facet}`
 ( which is `std::complex<FloatT>` in this case ).
 
 This way, the complex form would be specified by passing `complex_form`
@@ -778,7 +778,7 @@ First, the one that doesn't:
         const auto coord2 = strf::fmt(coordinates.second).set_float_format(float_fmt);
         const auto write_coord1 = strf::make_printer<CharT>(pre, facets, coord1);
         const auto write_coord2 = strf::make_printer<CharT>(pre, facets, coord2);
-        const auto charset = strf::use_facet<strf::charset_c<CharT>, representative>(facets);
+        const auto charset = strf::get_facet<strf::charset_c<CharT>, representative>(facets);
 
         return [charset, form, write_coord1, write_coord2] (strf::destination<CharT>& dst)
             {

docs/howto_override_printable_types.adoc

@@ -7,7 +7,7 @@ http://www.boost.org/LICENSE_1_0.txt)
 
 :printable_overrider_c: <<strf_hpp#printable_overrider_c,printable_overrider_c>>
 :make_printer: <<strf_hpp#make_printer,make_printer>>
-:use_facet: <<strf_hpp#use_facet,use_facet>>
+:get_facet: <<strf_hpp#get_facet,get_facet>>
 :pack: <<strf_hpp#pack,pack>>
 :set_alignment_format: <<strf_hpp#alignment_format_specifier,set_alignment_format>>
 :get_alignment_format: <<strf_hpp#alignment_format_specifier,get_alignment_format>>
@@ -140,7 +140,7 @@ constexpr auto italian_bool = strf::constrain<is_bool>(italian_bool_facet{});
 <1> `strf::{representative_of_printable}<__X__>`
     commonly aliases to `__X__`, and it does so for `bool`.
     However, is a good practice to use it (instead `__X__`), because it is
-    what the library uses (__i.e.__ parameterizes `<<strf_hpp#use_facet,use_facet>>`
+    what the library uses (__i.e.__ parameterizes `<<strf_hpp#get_facet,get_facet>>`
     with ) when "deciding" whether to apply a facet or not.
 
 Now we are ready:

docs/ref_facets_pack.adoc

@@ -8,7 +8,7 @@ http://www.boost.org/LICENSE_1_0.txt)
 :facets_pack: <<facets_pack,facets_pack>>
 :constrained_fpe: <<constrained_fpe,constrained_fpe>>
 
-:use_facet: <<use_facet,use_facet>>
+:get_facet: <<get_facet,get_facet>>
 :facet_category: <<facet_category,facet_category>>
 :facet_traits: <<facet_traits,facet_traits>>
 :FacetCategory: <<FacetCategory, FacetCategory>>
@@ -97,12 +97,12 @@ Return type:: `{facets_pack}<std::remove_cvref_t<T>>\...>`
 Return value:: A `{facets_pack}` object initialized with `std::forward<T>(args)\...`
 ====
 
-=== Function template `use_facet` [[use_facet]]
+=== Function template `get_facet` [[get_facet]]
 ====
 [source,cpp]
 ----
 template <typename FCat, typename Tag, typename ... T>
-constexpr decltype(auto) use_facet(const facets_pack<T...>& fp);
+constexpr decltype(auto) get_facet(const facets_pack<T...>& fp);
 ----
 Effects:: If <<has_facet, `has_facet<FCat, Tag>(fp)`>> returns `true` then
           returns `<<do_get_facet,do_get_facet>><FCat, Tag>(fp)`, otherwise
@@ -114,7 +114,7 @@ Compile-time requirements::  `FCat` is a _{FacetCategory}_ type.
 === Hypothetical function template `has_facet`
 NOTE: This function template does not exist in this library.
        It is only documented to help to explain the
-      `{use_facet}` function template.
+      `{get_facet}` function template.
 ====
 [source,cpp]
 ----
@@ -139,7 +139,7 @@ Compile-time requirements::
 === Hypothetical function template `do_get_facet`
 NOTE: This function template is not part of the library.
       It is only documented to help to explain the
-      `{use_facet}` function template
+      `{get_facet}` function template
 ====
 [source,cpp]
 ----
@@ -164,7 +164,7 @@ class constrained_fpe;
 The class template `constrained_fpe` is designed to be used in
 `{facets_pack}`. `constrained_fpe<Filter, FPE>`
 holds a value of `FPE` that will only be returned by
-`{use_facet}<Category, Tag>` if `Filter<Tag>::value` is `true`.
+`{get_facet}<Category, Tag>` if `Filter<Tag>::value` is `true`.
 
 Compile-time requirements::
 - `Filter` is a __{UnaryTypeTrait}__. For any type `T`, the expression

docs/ref_printable_types_requirements.adoc

@@ -24,7 +24,7 @@ http://www.boost.org/LICENSE_1_0.txt)
 
 :constrain: <<constrain,constrain>>
 :constrained_fpe: <<constrained_fpe,constrained_fpe>>
-:use_facet: <<use_facet,use_facet>>
+:get_facet: <<get_facet,get_facet>>
 :tag: <<tag,tag>>
 :rank: <<rank,rank>>
 :join: <<join,join>>
@@ -94,7 +94,7 @@ situations ( for example, the objects created by `fmt` and `{join}` ).
 ----
 T::representative
 ----
-The type used as the template argument in `{use_facet}`.
+The type used as the template argument in `{get_facet}`.
 This means it is the type that is tested by the
 the __UnaryTypeTrait__ template argument passed to
 `{constrain}` or `{constrained_fpe}`.
@@ -273,7 +273,7 @@ If `{printable_def_of}<Arg>::<<PrintableDef_is_overridable,is_overridable>>::val
 `make_printer` returns
 [source,cpp,subs=normal]
 ----
-{use_facet}< {printable_overrider_c}, {representative_of_printable}<Arg> > (facets)
+{get_facet}< {printable_overrider_c}, {representative_of_printable}<Arg> > (facets)
     .make_printer({tag}<CharT>{}, pre, facets, arg);
 ----
 

docs/tutorial.adoc

@@ -263,7 +263,7 @@ auto str2 = strf::to_string.with(my_facets) (/{asterisk} \... {asterisk}/);
 
 The `facets_pack` class template is designed more similarly to `std::tuple` than to `std::locale`.
 It stores all the facets objects by value, and accessing one them (
-with the `<<strf_hpp#use_facet,strf::use_facet>>` function template ) is just as fast as
+with the `<<strf_hpp#get_facet,strf::get_facet>>` function template ) is just as fast as
 calling a trivial getter function.
 
 Any value that can be passed to the `with` function, can also be passed to `pack`,

docs/why_not_std_locale.adoc

@@ -45,10 +45,10 @@ to as of `std::tuple`, holding its elements by value,
 in contrast to `std::locale` were they
 are managed through reference counting.
 
-`strf::use_facet` is as fast as a typical getter: it
+`strf::get_facet` is as fast as a typical getter: it
 just returns the reference of the requested object, or,
 if it is not present, a default value,
-while `std::use_facet` probably needs
+while `std::get_facet` probably needs
 to perform some run-time processing.
 
 There is no base class that facets in Strf need to derive from.

examples/extend_input_base64.cpp

@@ -267,7 +267,7 @@ struct printable_def<xxx::base64_input>
         , const FPack& facets
         , const input_with_fmt& arg )
     {
-        auto f = strf::use_facet<xxx::base64_facet_c, representative>(facets);
+        auto f = strf::get_facet<xxx::base64_facet_c, representative>(facets);
         return xxx::base64_printer<CharT>{f, arg.value(), arg.indentation()};
     }
 
@@ -278,7 +278,7 @@ struct printable_def<xxx::base64_input>
         , const FPack& facets
         , const input_with_fmt& arg )
     {
-        auto f = strf::use_facet<xxx::base64_facet_c, representative>(facets);
+        auto f = strf::get_facet<xxx::base64_facet_c, representative>(facets);
         xxx::base64_printer<CharT> printer{f, arg.value(), arg.indentation()};
         pre->add_size(printer.calculate_size());
         return printer;

examples/extend_input_ipv6.cpp

@@ -111,10 +111,10 @@ class ipv6_printer
         , const strf::value_and_format<T...>& arg )
         : addr_(arg.value())
         , alignment_fmt_(arg.get_alignment_format())
-        , lettercase_(strf::use_facet<strf::lettercase_c, xxx::ipv6address>(facets))
+        , lettercase_(strf::get_facet<strf::lettercase_c, xxx::ipv6address>(facets))
         , style_(arg.get_ipv6style())
     {
-        auto encoding = use_facet<strf::charset_c<CharT>, xxx::ipv6address>(facets);
+        auto encoding = get_facet<strf::charset_c<CharT>, xxx::ipv6address>(facets);
 
         encode_fill_fn_ = encoding.encode_fill_func();
         init_and_premeasure_(pre, encoding);

examples/extend_input_std_complex_v2.cpp

@@ -188,7 +188,7 @@ struct printable_def<std::complex<FloatT>>
         const auto coord2 = strf::fmt(coordinates.second).set_float_format(float_fmt);
         const auto write_coord1 = strf::make_printer<CharT>(pre, facets, coord1);
         const auto write_coord2 = strf::make_printer<CharT>(pre, facets, coord2);
-        const auto charset = strf::use_facet<strf::charset_c<CharT>, representative>(facets);
+        const auto charset = strf::get_facet<strf::charset_c<CharT>, representative>(facets);
 
         return [charset, form, write_coord1, write_coord2] (strf::destination<CharT>& dst)
             {
@@ -238,12 +238,12 @@ struct printable_def<std::complex<FloatT>>
                 assert(form == complex_form::polar);
                 using rt = representative;
                 if (pre->has_remaining_width()) {
-                    auto wcalc = strf::use_facet<strf::width_calculator_c, rt>(facets);
+                    auto wcalc = strf::get_facet<strf::width_calculator_c, rt>(facets);
                     pre->add_width(wcalc.char_width(strf::utf_t<char32_t>{}, anglechar));
                     pre->add_width(1);
                 }
                 if (PreMeasurements::size_demanded) {
-                    auto encoding = strf::use_facet<strf::charset_c<CharT>, rt>(facets);
+                    auto encoding = strf::get_facet<strf::charset_c<CharT>, rt>(facets);
                     pre->add_size(encoding.encoded_char_size(anglechar));
                     pre->add_size(1);
                 }

include/strf/detail/facets/numpunct.hpp

@@ -651,7 +651,7 @@ class has_punct
 
     using has_numpunct_type = decltype
         ( test_numpunct
-            ( use_facet< strf::numpunct_c<Base>, InputT >(fp())) );
+            ( get_facet< strf::numpunct_c<Base>, InputT >(fp())) );
 
 public:
 

include/strf/detail/printable_types/bool.hpp

@@ -142,7 +142,7 @@ struct printable_def<bool>
     {
         pre->add_width(static_cast<strf::width_t>(5 - x));
         pre->add_size(5 - (int)x);
-        return detail::bool_printer<CharT>{x, strf::use_facet<strf::lettercase_c, bool>(fp)};
+        return detail::bool_printer<CharT>{x, strf::get_facet<strf::lettercase_c, bool>(fp)};
     }
 
     template <typename CharT, typename PreMeasurements, typename FPack, typename... T>
@@ -157,11 +157,11 @@ struct printable_def<bool>
         const int w = 5 - (int) value;
         const auto afmt = x.get_alignment_format();
         const auto fmt_width = afmt.width.round();
-        const auto lcase = strf::use_facet<strf::lettercase_c, bool>(fp);
+        const auto lcase = strf::get_facet<strf::lettercase_c, bool>(fp);
 
         if (fmt_width > w) {
             const int fillcount = fmt_width - w;
-            auto charset = strf::use_facet<charset_c<CharT>, bool>(fp);
+            auto charset = strf::get_facet<charset_c<CharT>, bool>(fp);
 
             pre->add_width(static_cast<strf::width_t>(fmt_width));
             pre->add_size(w + fillcount * charset.encoded_char_size(afmt.fill));

include/strf/detail/printable_types/char.hpp

@@ -39,8 +39,8 @@ class fmt_char_printer
         , afmt_(arg.get_alignment_format())
         , ch_(static_cast<CharT>(arg.value()))
     {
-        auto charset = use_facet_<strf::charset_c<CharT>>(facets);
-        auto&& wcalc = use_facet_<strf::width_calculator_c>(facets);
+        auto charset = get_facet_<strf::charset_c<CharT>>(facets);
+        auto&& wcalc = get_facet_<strf::width_calculator_c>(facets);
         encode_fill_fn_ = charset.encode_fill_func();
         init_(pre, wcalc, charset);
     }
@@ -58,10 +58,10 @@ class fmt_char_printer
 
     template <typename Category, typename FPack>
     static STRF_HD
-    STRF_DECLTYPE_AUTO((strf::use_facet<Category, CharT>(std::declval<FPack>())))
-    use_facet_(const FPack& fp)
+    STRF_DECLTYPE_AUTO((strf::get_facet<Category, CharT>(std::declval<FPack>())))
+    get_facet_(const FPack& fp)
     {
-        return fp.template use_facet<Category, CharT>();
+        return fp.template get_facet<Category, CharT>();
     }
 
     template <typename PreMeasurements, typename WCalc, typename Charset>
@@ -170,8 +170,8 @@ class fmt_conv_char32_printer
         : count_(arg.scount())
         , ch_(arg.value())
     {
-        auto charset = strf::use_facet<charset_c<DstCharT>, char32_t>(facets);
-        auto&& wcalc = use_facet<strf::width_calculator_c, char32_t>(facets);
+        auto charset = strf::get_facet<charset_c<DstCharT>, char32_t>(facets);
+        auto&& wcalc = get_facet<strf::width_calculator_c, char32_t>(facets);
         auto char_width = wcalc.char_width(strf::utf_t<char32_t>{}, ch_);
         init_(pre, charset, arg.get_alignment_format(), char_width);
     }
@@ -298,8 +298,8 @@ struct char_printing
 
         pre->add_size(1);
         if (pre->has_remaining_width()) {
-            auto&& wcalc = use_facet<strf::width_calculator_c, DstCharT>(facets);
-            auto charset = use_facet<strf::charset_c<DstCharT>, SrcCharT>(facets);
+            auto&& wcalc = get_facet<strf::width_calculator_c, DstCharT>(facets);
+            auto charset = get_facet<strf::charset_c<DstCharT>, SrcCharT>(facets);
             auto w = wcalc.char_width(charset, static_cast<DstCharT>(x));
             pre->add_width(w);
         }
@@ -359,12 +359,12 @@ struct printable_def<char32_t>
         , char32_t x ) noexcept
         -> strf::detail::conv_char32_printer<DstCharT>
     {
-        auto encoding = strf::use_facet<charset_c<DstCharT>, char32_t>(facets);
+        auto encoding = strf::get_facet<charset_c<DstCharT>, char32_t>(facets);
         STRF_MAYBE_UNUSED(encoding);
         auto encoded_char_size = encoding.encoded_char_size(x);
         pre->add_size(encoded_char_size);
         if (pre->has_remaining_width()) {
-            auto&& wcalc = use_facet<strf::width_calculator_c, char32_t>(facets);
+            auto&& wcalc = get_facet<strf::width_calculator_c, char32_t>(facets);
             pre->add_width(wcalc.char_width(strf::utf_t<char32_t>{}, x));
         }
         return strf::detail::conv_char32_printer<DstCharT>

include/strf/detail/printable_types/float.hpp

@@ -2233,16 +2233,16 @@ class punct_double_printer
         , const FPack& facets
         , const detail::float_with_fmt
             < FloatT, strf::float_format_specifier_full_dynamic, HasAlignment >& arg )
-        : lettercase_(strf::use_facet<strf::lettercase_c, FloatT>(facets))
+        : lettercase_(strf::get_facet<strf::lettercase_c, FloatT>(facets))
     {
-        auto charset = use_facet<strf::charset_c<CharT>, FloatT>(facets);
+        auto charset = get_facet<strf::charset_c<CharT>, FloatT>(facets);
         encode_fill_ = charset.encode_fill_func();
         encode_char_ = charset.encode_char_func();
 
         auto notation = arg.float_notation();
         if (arg.get_float_format().punctuate) {
-            auto punct_dec = strf::use_facet<strf::numpunct_c<10>, FloatT>(facets);
-            auto punct_hex = strf::use_facet<strf::numpunct_c<16>, FloatT>(facets);
+            auto punct_dec = strf::get_facet<strf::numpunct_c<10>, FloatT>(facets);
+            auto punct_hex = strf::get_facet<strf::numpunct_c<16>, FloatT>(facets);
             grouping_ = punct_dec.grouping();
             thousands_sep_ = punct_dec.thousands_sep();
             decimal_point_ = ( notation != strf::float_notation::hex
@@ -2287,9 +2287,9 @@ class punct_double_printer
         ( PreMeasurements* pre
         , const FPack& facets
         , const detail::float_with_fmt<FloatT, FloatFormatter, HasAlignment>& arg )
-        : lettercase_(strf::use_facet<strf::lettercase_c, FloatT>(facets))
+        : lettercase_(strf::get_facet<strf::lettercase_c, FloatT>(facets))
     {
-        auto charset = use_facet<strf::charset_c<CharT>, FloatT>(facets);
+        auto charset = get_facet<strf::charset_c<CharT>, FloatT>(facets);
         encode_fill_ = charset.encode_fill_func();
         auto r = strf::detail::init_float_printer_data
             ( data_, arg.value(), grouping_, arg.get_float_format()
@@ -2590,7 +2590,7 @@ struct float_printing
         ( strf::tag<CharT>, PreMeasurements* pre, const FPack& fp, FloatT x ) noexcept
         -> strf::detail::fast_double_printer<CharT>
     {
-        const fast_double_printer<CharT> p(x, strf::use_facet<strf::lettercase_c, float>(fp));
+        const fast_double_printer<CharT> p(x, strf::get_facet<strf::lettercase_c, float>(fp));
         if (pre->has_remaining_width() || PreMeasurements::size_demanded) {
             const auto s = p.size();
             pre->add_width(static_cast<std::int16_t>(s));