Turn printable_overrider_c into a struct template.

This way the user doesn't need to remember to constrain the facet

Author: robhz786

docs/howto_add_printable_types.adoc

@@ -19,7 +19,6 @@ http://www.boost.org/LICENSE_1_0.txt)
 :format_specifiers:     <<strf_hpp#PrintableDef_format_specifiers,format_specifiers>>
 :FormatSpecifier:       <<strf_hpp#FormatSpecifier,FormatSpecifier>>
 :printable_overrider_c: <<strf_hpp#printable_overrider_c,printable_overrider_c>>
-:dont_override:         <<strf_hpp#dont_override,dont_override>>
 :premeasurements:       <<strf_hpp#premeasurements,premeasurements>>
 :measure:               <<strf_hpp#measure,measure>>
 :value_and_format:      <<strf_hpp#value_and_format,value_and_format>>

docs/howto_override_printable_types.adoc

@@ -6,6 +6,7 @@ http://www.boost.org/LICENSE_1_0.txt)
 ////
 
 :printable_overrider_c: <<strf_hpp#printable_overrider_c,printable_overrider_c>>
+:printable_overrider_c_of: <<strf_hpp#printable_overrider_c_of,printable_overrider_c_of>>
 :make_printer: <<strf_hpp#make_printer,make_printer>>
 :get_facet: <<strf_hpp#get_facet,get_facet>>
 :pack: <<strf_hpp#pack,pack>>
@@ -32,25 +33,20 @@ http://www.boost.org/LICENSE_1_0.txt)
 Strf allows you not only to <<howto_add_printable_types#,add printable types>>,
 but also to override existing ones. The procedure is similar; the
 main difference is that instead of defining a _{PrintableDef}_ type,
-you create a facet of the `{printable_overrider_c}` category,
+you create a facet of the `{printable_overrider_c}<...>` category,
 which is almost the same thing.
-So this document presumes you already know how to do that.
+So this document presumes you already know how to do add printables types.
 If you don't,
 <<howto_add_printable_types#CreatePrintableDef,click here>>
 to get some explanation.
 
-
-The facet shall contain the
-`make_printer` member function templates that will
-replace those defined in the _{PrintableDef}_ class of the
-overrided type.
 For example, one could define a facet to override the `bool` like this:
 
 [source,cpp,subs=normal]
 ----
 struct italian_bool_facet
 {
-    using category = strf::{printable_overrider_c};
+    using category = strf::{printable_overrider_c_of}<bool>;
 
     template <typename CharT, typename Pre, typename FPack>
     constexpr static auto make_printer
@@ -85,21 +81,15 @@ so instead of hardcoded strings like `"vero"`, and `"falso"`
 , we could use member variables, which would probably make more sense ).
 
 Just as it is usual in __PrintableDef__ classes,
-you can see that we have two `make_printer` fuctions
-( though the first one is unnecessary ).
+you can see that we have two `make_printer` fuctions.
 The second one handles `bool` values with formatting.
-Even if we don't define it, an expression like
-`strf::right(true, 10, '.')`
-is still well-formed, because the format functions
-that are applicable to a printable type keep being the same
-when we override it. We can't change them.
-So it makes sense to overload `make_printer`
-with `{value_and_format}` argument even
-if you don't want to support formatting, just to
-add a `static_assert` to emit a clear error message.
-
-But if do you want support formatting then
-check in the <<strf_hpp#printable_types_list,documentation>> what
+
+The format functions that are applicable to a printable
+type keep being the same when we override it. We can't change them.
+Defining the  `format_specifiers` type alias in the overrider facet
+has not effect.
+
+Check in the <<strf_hpp#printable_types_list,documentation>> what
 are the format functions ( or the __FormatSpecifiers__ )
 applicable to the printable type you are overriding.
 If you take a look at the part the covers
@@ -115,35 +105,14 @@ taking the `{value_and_format}` argument and add
 a `static_assert` with an explanatory message.
 ////
 
-
 Things are more lenient regarding facets:
 you can completely ignore the facet categories that
 influence the original printable type, as well as consider others
 or <<howto_add_printable_types#creating_facet,new>> ones.
 You can see that although `bool` type is influenced
 by `{lettercase}` facet, our override just ignores it.
 
-Now we are almost ready to use our implementation.
-There is just a detail you *must*
-remember before using a facet object
-of the `printable_overrider_c` category &#x2014; you must __{constrain}__
-it to the types it aims to override:
-
-[source,cpp]
-----
-template <typename T>
-struct is_bool: std::is_same<T, strf::representative_of_printable<bool>> {}; // <1>
-
-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#get_facet,get_facet>>`
-    with ) when "deciding" whether to apply a facet or not.
-
-Now we are ready:
+Anyway, let's see the result:
 
 [source,cpp,subs=normal]
 ----
@@ -158,20 +127,6 @@ str = strf::to_string
 assert(str == "\...vero\.../..falso\...");
 ----
 
-
-[WARNING]
-====
-When a `printable_overrider_c` facet is not constrained, it affects all
-overridable printable types, which is certainly not what we want:
-
-[source,cpp,subs=normal]
-----
-auto str = strf::to_string.with(italian_bool_facet{})
-    (true, '/', false, '/', 1.0, '/', 0.0, '/', (void*)0);
-assert(str == "vero/falso/vero/falso/falso");
-----
-====
-
 [NOTE]
 ====
 Some printable types are not overridable.

docs/quick_reference.adoc

@@ -712,7 +712,7 @@ When the argument associated with a `"{"` does not exist, the library does two t
                                        |Yes | Notifies nonconformities to the character encoding.
 |`<<tr_string_error,tr_error_notifier_c>>`  |No  | Notifies errors on the tr-string
 |`<<width_calculator,width_calculator_c>>`  |Yes |Defines how the width is calculated
-|`<<howto_override_printable_types#,printable_overrider_c>>`     |Yes   | Overrides printable types
+|`<<howto_override_printable_types#,printable_overrider_c<_R_>>>`     |Yes   | Overrides printable types
 |===
 
 [[numpunct]]

docs/ref_printable_types_requirements.adoc

@@ -231,40 +231,50 @@ using forwarded_printable_type = typename {printable_def_of}<T>::<<PrintableDef_
 } // namespace strf
 ----
 
-=== Facet category `printable_overrider_c` [[printable_overrider_c]]
-
-////
-to-do
-////
-
-A facet of this category should **aways** be <<constrain,constrained>> to the
-printable type intended to be overriden.
+=== Template facet category `printable_overrider_c` [[printable_overrider_c]]
 
 [source,cpp,subs=normal]
 ----
 namespace strf {
 
+template <typename R>
 struct printable_overrider_c {
     static constexpr bool constrainable = true;
 
-    constexpr static <<dont_override,dont_override>> get_default() noexcept {
+    constexpr static <<dont_override,dont_override>><R> get_default() noexcept {
         return {};
     }
 };
 
 } // namespace strf
 ----
 
-==== Struct `dont_override` [[dont_override]]
+The template parameter `R` shall be the same as the `{representative_of_printable}<P>`,
+where `P` the printable type to be overriden.
+
+=== Type alias `printable_overrider_c_of` [[printable_overrider_c_of]]
+
+[source,cpp,subs=normal]
+----
+namespace strf {
+template <typename Printable>
+using printable_overrider_c_of =
+    printable_overrider_c< representative_of_printable<Printable> >;
+}
+----
+
+=== Struct template `dont_override` [[dont_override]]
+
 
-`dont_override` is the default facet of `printable_overrider_c` category.
+`dont_override<_T_>` is the default facet of `printable_overrider_c<_T>` category.
 
 [source,cpp,subs=normal]
 ----
 namespace strf {
 
+template <typename T>
 struct dont_override {
-    using category = printable_overrider_c;
+    using category = printable_overrider_c<R>;
 };
 
 } // namespace strf
@@ -286,7 +296,10 @@ If `{printable_def_of}<Arg>::<<PrintableDef_is_overridable,is_overridable>>::val
 `make_printer` returns
 [source,cpp,subs=normal]
 ----
-{get_facet}< {printable_overrider_c}, {representative_of_printable}<Arg> > (facets)
+{get_facet}
+    < {printable_overrider_c}<{representative_of_printable}<Arg>>
+    , {representative_of_printable}<Arg> >
+    (facets)
     .make_printer({tag}<CharT>{}, pre, facets, arg);
 ----
 

docs/why_not_std_locale.adoc

@@ -91,9 +91,8 @@ auto punct = strf::numpunct<10> (3, 2, 1)
 ( Be aware that `strf::numpunct` does not affect `bool` values,
 contrary to `std::numpunct` which
 has the `truename()` and `falsename()` functions.
-Instead, in Strf there is the `<<howto_override_printable_types#,printable_overrider_c>>`
-facet category, which enables you to override how
-values of `bool` are printed. )
+If you what to change how `bool` values are printed,
+see <<howto_override_printable_types#,how to override printable types>>.
 
 // But perhaps the main reason is that the goals
 // re different:

examples/override_bool.cpp

@@ -11,7 +11,7 @@
 
 struct my_bool_overrider
 {
-    using category = strf::printable_overrider_c;
+    using category = strf::printable_overrider_c_of<bool>;
 
     template <typename CharT, typename PreMeasurements, typename FPack, typename... T>
     constexpr auto make_printer
@@ -46,10 +46,7 @@ struct my_bool_overrider
 
 static_assert(strf::is_printable_and_overridable_v<bool>, "bool not overridable");
 
-template <typename T>
-struct is_bool: std::is_same<T, strf::representative_of_printable<bool>> {};
-
-constexpr auto italian_bool = strf::constrain<is_bool>(my_bool_overrider{{"falso", "vero"}});
+constexpr auto italian_bool = my_bool_overrider{{"falso", "vero"}};
 
 int main()
 {
@@ -63,11 +60,6 @@ int main()
         , strf::center(false, 10, '.') );
     assert(str == "...vero.../..falso...");
 
-    // what happens when you don't constrain an overrider facet:
-    str = strf::to_string.with(my_bool_overrider{{"falso", "vero"}})
-        (true, '/', false, '/', 1.0, '/', 0.0, '/', static_cast<void*>(nullptr));
-    assert(str == "vero/falso/vero/falso/falso");
-
     return 0;
 }
 

include/strf/detail/printable_def.hpp

@@ -346,16 +346,11 @@ constexpr detail_format_functions::fmt_fn fmt {};
 
 }  // namespace format_functions
 
+template <typename Representative>
 struct printable_overrider_c;
-struct dont_override;
-
-using print_override_c
-STRF_DEPRECATED_MSG("print_override_c was renamed printable_overrider_c")
-= printable_overrider_c;
 
-using no_print_override
-STRF_DEPRECATED_MSG("no_print_override was renamed dont_override")
-= dont_override;
+template <typename Representative>
+struct dont_override;
 
 namespace detail {
 
@@ -407,16 +402,18 @@ constexpr STRF_HD decltype(auto) make_printer
         .make_printer(ChTag{}, p, fp, Helper::convert_printable_arg(arg));
 }
 
+template <typename Representative>
 struct dont_override
 {
-    using category = printable_overrider_c;
+    using category = printable_overrider_c<Representative>;
 };
 
+template <typename Representative>
 struct printable_overrider_c
 {
     static constexpr bool constrainable = true;
 
-    constexpr static STRF_HD dont_override get_default() noexcept
+    constexpr static STRF_HD dont_override<Representative> get_default() noexcept
     {
         return {};
     }
@@ -479,6 +476,10 @@ using extract_representative = typename representative_from_printable_def<Printa
 template <typename T>
 using representative_of_printable = detail::extract_representative<strf::printable_def_of<T>>;
 
+template <typename Printable>
+using printable_overrider_c_of =
+    printable_overrider_c< representative_of_printable<Printable> >;
+
 template <typename CharT, typename PreMeasurements, typename FPack, typename Arg>
 using printer_type = typename
     detail::helper_for_printing_with_premeasurements

include/strf/detail/printing_helpers.hpp

@@ -111,15 +111,15 @@ using select_printable_arg_converter_for_printing_with_premeasurements = typenam
     <PrintableDef, DefOrFacet, CharT, PreMeasurements, FPack, Arg>
     ::type;
 
-template <typename Overrider, typename OverrideTag>
+template <typename Overrider, typename Representative>
 struct overrider_getter
 {
     using printable_def_or_facet_type = Overrider;
 
     template <typename FPack>
     static constexpr STRF_HD const Overrider& get_printable_def_or_facet(const FPack& fp)
     {
-        return strf::get_facet<strf::printable_overrider_c, OverrideTag>(fp);
+        return strf::get_facet<strf::printable_overrider_c<Representative>, Representative>(fp);
     }
 };
 
@@ -146,12 +146,12 @@ struct printable_def_or_facet_getter_selector_2
     static_assert(Overridable, "");
     using representative = detail::extract_representative<PrintableDef>;
     using overrider_ = decltype
-        ( strf::get_facet<strf::printable_overrider_c, representative>
+        ( strf::get_facet<strf::printable_overrider_c<representative>, representative>
           (std::declval<FPack>()) );
 
     using overrider = strf::detail::remove_cvref_t<overrider_>;
     using printable_def_or_facet_getter_type = typename std::conditional
-        < std::is_same<overrider, strf::dont_override>::value
+        < std::is_same<overrider, strf::dont_override<representative>>::value
         , printable_def_getter<PrintableDef>
         , overrider_getter<overrider, representative> >
         ::type;
@@ -399,9 +399,9 @@ class polymorphic_printer_that_calls_print_from_facet
 
     STRF_HD void print_to(strf::destination<CharT>& dst) const override
     {
+        using representative = detail::extract_representative<PrintableDef>;
         strf::get_facet
-            < strf::printable_overrider_c
-            , detail::extract_representative<PrintableDef> > (facets_())
+            < strf::printable_overrider_c<representative>, representative > (facets_())
             .print(dst, facets_(), printable_);
     }
 

tests/add_and_override_printable_types.cpp

@@ -130,7 +130,7 @@ STRF_TEST_FUNC void test_printable_def_without_make_printer()
 
 struct mytype_overrider_impl
 {
-    using category = strf::printable_overrider_c;
+    using category = strf::printable_overrider_c_of<mytype>;
 
     template <typename CharT, typename FPack>
     STRF_HD static void print
@@ -494,7 +494,7 @@ STRF_TEST_FUNC void test_make_printer_that_returns_lambda()
 
 struct mytype2_overrider_impl
 {
-    using category = strf::printable_overrider_c;
+    using category = strf::printable_overrider_c_of<mytype2>;
 
     template <typename CharT, typename Pre, typename FPack>
     STRF_HD static auto make_printer