Raise minimum ICU version to 4.2

StringPiece is only available in 4.2+ and is required for proper parsing
and formatting.
As this version is now "old enough", just assume 4.2+ removing many
conditionals.

Author: Flamefire

doc/changelog.txt

@@ -10,6 +10,7 @@
 
 - 1.88.0
     - Fix parsing of numbers in floating point format to integers
+    - Require ICU 4.2 or later
 - 1.86.0
     - Make ICU implementation of `to_title` threadsafe
     - Add allocator support to `utf_to_utf`

src/boost/locale/icu/collator.cpp

@@ -16,13 +16,8 @@
 #include <limits>
 #include <memory>
 #include <unicode/coll.h>
+#include <unicode/stringpiece.h>
 #include <vector>
-#if BOOST_LOCALE_ICU_VERSION >= 402
-#    define BOOST_LOCALE_WITH_STRINGPIECE 1
-#    include <unicode/stringpiece.h>
-#else
-#    define BOOST_LOCALE_WITH_STRINGPIECE 0
-#endif
 
 #ifdef BOOST_MSVC
 #    pragma warning(disable : 4244) // 'argument' : conversion from 'int'
@@ -43,7 +38,6 @@ namespace boost { namespace locale { namespace impl_icu {
             return res;
         }
 
-#if BOOST_LOCALE_WITH_STRINGPIECE
         int do_utf8_compare(collate_level level,
                             const char* b1,
                             const char* e1,
@@ -55,7 +49,6 @@ namespace boost { namespace locale { namespace impl_icu {
             icu::StringPiece right(b2, e2 - b2);
             return get_collator(level).compareUTF8(left, right, status);
         }
-#endif
 
         int do_ustring_compare(collate_level level,
                                const CharType* b1,
@@ -159,7 +152,6 @@ namespace boost { namespace locale { namespace impl_icu {
         bool is_utf8_;
     };
 
-#if BOOST_LOCALE_WITH_STRINGPIECE
     template<>
     int collate_impl<char>::do_real_compare(collate_level level,
                                             const char* b1,
@@ -173,7 +165,7 @@ namespace boost { namespace locale { namespace impl_icu {
         else
             return do_ustring_compare(level, b1, e1, b2, e2, status);
     }
-#endif
+
     std::locale create_collate(const std::locale& in, const cdata& cd, char_facet_t type)
     {
         switch(type) {

src/boost/locale/icu/conversion.cpp

@@ -13,11 +13,8 @@
 #include <limits>
 #include <unicode/locid.h>
 #include <unicode/normlzr.h>
+#include <unicode/ucasemap.h>
 #include <unicode/ustring.h>
-#if BOOST_LOCALE_ICU_VERSION >= 308
-#    include <unicode/ucasemap.h>
-#    define BOOST_LOCALE_WITH_CASEMAP
-#endif
 #include <vector>
 
 namespace boost { namespace locale { namespace impl_icu {
@@ -72,7 +69,6 @@ namespace boost { namespace locale { namespace impl_icu {
         std::string encoding_;
     }; // converter_impl
 
-#ifdef BOOST_LOCALE_WITH_CASEMAP
     template<typename T>
     struct get_casemap_size_type;
 
@@ -193,26 +189,17 @@ namespace boost { namespace locale { namespace impl_icu {
         raii_casemap<U8Char> map_;
     }; // converter_impl
 
-#endif // BOOST_LOCALE_WITH_CASEMAP
-
     std::locale create_convert(const std::locale& in, const cdata& cd, char_facet_t type)
     {
         switch(type) {
             case char_facet_t::nochar: break;
             case char_facet_t::char_f:
-#ifdef BOOST_LOCALE_WITH_CASEMAP
                 if(cd.is_utf8())
                     return std::locale(in, new utf8_converter_impl<char>(cd));
-#endif
                 return std::locale(in, new converter_impl<char>(cd));
             case char_facet_t::wchar_f: return std::locale(in, new converter_impl<wchar_t>(cd));
 #ifndef BOOST_LOCALE_NO_CXX20_STRING8
-            case char_facet_t::char8_f:
-#    if defined(BOOST_LOCALE_WITH_CASEMAP)
-                return std::locale(in, new utf8_converter_impl<char8_t>(cd));
-#    else
-                return std::locale(in, new converter_impl<char8_t>(cd));
-#    endif
+            case char_facet_t::char8_f: return std::locale(in, new utf8_converter_impl<char8_t>(cd));
 #elif defined(__cpp_char8_t)
             case char_facet_t::char8_f: break;
 #endif

src/boost/locale/icu/date_time.cpp

@@ -67,10 +67,6 @@ namespace boost { namespace locale { namespace impl_icu {
             const double rounded_time = std::floor(calendar_->getTime(err) / U_MILLIS_PER_SECOND) * U_MILLIS_PER_SECOND;
             calendar_->setTime(rounded_time, err);
             check_and_throw_dt(err);
-#if BOOST_LOCALE_ICU_VERSION < 402
-            // workaround old/invalid data, it should be 4 in general
-            calendar_->setMinimalDaysInFirstWeek(4);
-#endif
             encoding_ = dat.encoding();
         }
         calendar_impl(const calendar_impl& other)
@@ -79,15 +75,9 @@ namespace boost { namespace locale { namespace impl_icu {
             encoding_ = other.encoding_;
         }
 
-        calendar_impl* clone() const override
-        {
-            return new calendar_impl(*this);
-        }
+        calendar_impl* clone() const override { return new calendar_impl(*this); }
 
-        void set_value(period::marks::period_mark p, int value) override
-        {
-            calendar_->set(to_icu(p), int32_t(value));
-        }
+        void set_value(period::marks::period_mark p, int value) override { calendar_->set(to_icu(p), int32_t(value)); }
 
         int get_value(period::marks::period_mark p, value_type type) const override
         {
@@ -202,10 +192,7 @@ namespace boost { namespace locale { namespace impl_icu {
             check_and_throw_dt(err);
             return diff;
         }
-        void set_timezone(const std::string& tz) override
-        {
-            calendar_->adoptTimeZone(get_time_zone(tz));
-        }
+        void set_timezone(const std::string& tz) override { calendar_->adoptTimeZone(get_time_zone(tz)); }
         std::string get_timezone() const override
         {
             icu::UnicodeString tz;

src/boost/locale/icu/formatters_cache.cpp

@@ -92,16 +92,13 @@ namespace boost { namespace locale { namespace impl_icu {
             case num_fmt_type::curr_iso:
                 return icu::NumberFormat::createInstance(locale_, UNUM_CURRENCY_ISO, err);
                 break;
-#elif BOOST_LOCALE_ICU_VERSION >= 402
+#else
             case num_fmt_type::curr_nat:
                 return icu::NumberFormat::createInstance(locale_, icu::NumberFormat::kCurrencyStyle, err);
                 break;
             case num_fmt_type::curr_iso:
                 return icu::NumberFormat::createInstance(locale_, icu::NumberFormat::kIsoCurrencyStyle, err);
                 break;
-#else
-            case num_fmt_type::curr_nat:
-            case num_fmt_type::curr_iso: return icu::NumberFormat::createCurrencyInstance(locale_, err); break;
 #endif
             case num_fmt_type::percent: return icu::NumberFormat::createPercentInstance(locale_, err); break;
             case num_fmt_type::spell: return new icu::RuleBasedNumberFormat(icu::URBNF_SPELLOUT, locale_, err); break;

src/boost/locale/icu/time_zone.cpp

@@ -13,14 +13,13 @@
 // Bug - when ICU tries to find a file that is equivalent to /etc/localtime it finds /usr/share/zoneinfo/localtime
 // that is just a symbolic link to /etc/localtime.
 //
-// It started in 4.0 and was fixed in version 4.6, also the fix was backported to the 4.4 branch so it should be
+// It was fixed in version 4.6, also the fix was backported to the 4.4 branch so it should be
 // available from 4.4.3... So we test if the workaround is required
 //
 // It is also relevant only for Linux, BSD and Apple (as I see in ICU code)
 //
 
-#if BOOST_LOCALE_ICU_VERSION >= 400 && BOOST_LOCALE_ICU_VERSION <= 406 \
-  && (BOOST_LOCALE_ICU_VERSION != 404 || U_ICU_VERSION_PATCHLEVEL_NUM >= 3)
+#if BOOST_LOCALE_ICU_VERSION <= 406 && (BOOST_LOCALE_ICU_VERSION != 404 || U_ICU_VERSION_PATCHLEVEL_NUM >= 3)
 #    if BOOST_OS_LINUX || BOOST_OS_BSD_FREE || defined(__APPLE__)
 #        define BOOST_LOCALE_WORKAROUND_ICU_BUG
 #    endif

test/test_formatting.cpp

@@ -49,16 +49,13 @@ std::string from_icu_string(const icu::UnicodeString& str)
 #    define BOOST_LOCALE_ICU_VERSION_EXACT 0
 #endif
 
-// Currency style changes between ICU versions, so get "real" value from ICU
-#if BOOST_LOCALE_ICU_VERSION >= 402
-
 std::string get_icu_currency_iso(const double value)
 {
-#    if BOOST_LOCALE_ICU_VERSION >= 408
+#if BOOST_LOCALE_ICU_VERSION >= 408
     auto styleIso = UNUM_CURRENCY_ISO;
-#    else
+#else
     auto styleIso = icu::NumberFormat::kIsoCurrencyStyle;
-#    endif
+#endif
     UErrorCode err = U_ZERO_ERROR;
     std::unique_ptr<icu::NumberFormat> fmt(icu::NumberFormat::createInstance(get_icu_test_locale(), styleIso, err));
     TEST_REQUIRE(U_SUCCESS(err) && fmt.get());
@@ -67,8 +64,6 @@ std::string get_icu_currency_iso(const double value)
     return from_icu_string(fmt->format(value, tmp));
 }
 
-#endif
-
 using format_style_t = std::ios_base&(std::ios_base&);
 
 #ifdef BOOST_LOCALE_WITH_ICU
@@ -425,12 +420,11 @@ void test_manip(std::string e_charset = "UTF-8")
 
     TEST_PARSE_FAILS(as::currency, "$", double);
 
-#if BOOST_LOCALE_ICU_VERSION >= 402
     TEST_FMT_PARSE_2(as::currency, as::currency_national, 1345, "$1,345.00");
     TEST_FMT_PARSE_2(as::currency, as::currency_national, 1345.34, "$1,345.34");
     TEST_FMT_PARSE_2(as::currency, as::currency_iso, 1345, get_icu_currency_iso(1345));
     TEST_FMT_PARSE_2(as::currency, as::currency_iso, 1345.34, get_icu_currency_iso(1345.34));
-#endif
+
     TEST_FMT_PARSE_1(as::spellout, 10, "ten");
 #if 402 <= BOOST_LOCALE_ICU_VERSION && BOOST_LOCALE_ICU_VERSION < 408
     if(e_charset == "UTF-8")
@@ -503,15 +497,13 @@ void test_manip(std::string e_charset = "UTF-8")
                        a_datetime,
                        icu_time_long,
                        a_time + a_timesec);
-#if !(BOOST_LOCALE_ICU_VERSION == 308 && defined(__CYGWIN__)) // Known failure due to ICU issue
     TEST_PARSE(as::time >> as::time_full >> as::time_zone("GMT+01:00"), "4:33:13 PM GMT+01:00", a_time + a_timesec);
     TEST_FMT_PARSE_3_2(as::time,
                        as::time_full,
                        as::time_zone("GMT+01:00"),
                        a_datetime,
                        icu_time_full,
                        a_time + a_timesec);
-#endif
 
     const std::string icu_def = get_ICU_datetime(as::time, a_datetime);
     const std::string icu_short = get_ICU_datetime(as::time_short, a_datetime);
@@ -760,11 +752,7 @@ void test_format_class(std::string charset = "UTF-8")
 
     // format with locale & encoding
     {
-#if BOOST_LOCALE_ICU_VERSION >= 400
         const auto expected = boost::locale::conv::utf_to_utf<CharType>("10,00\xC2\xA0€");
-#else
-        const auto expected = boost::locale::conv::utf_to_utf<CharType>("10,00 €"); // LCOV_EXCL_LINE
-#endif
         TEST_EQ(do_format<CharType>(loc, "{1,cur,locale=de_DE.UTF-8}", 10), expected);
     }
 
@@ -792,20 +780,14 @@ void test_format_class(std::string charset = "UTF-8")
     TEST_FORMAT_CLS("{1,cur}", 1234, "$1,234.00");
     TEST_FORMAT_CLS("{1,currency}", 1234, "$1,234.00");
     if(charset == "UTF-8") {
-#if BOOST_LOCALE_ICU_VERSION >= 400
         TEST_FORMAT_CLS("{1,cur,locale=de_DE}", 10, "10,00\xC2\xA0€");
-#else
-        TEST_FORMAT_CLS("{1,cur,locale=de_DE}", 10, "10,00 €");                     // LCOV_EXCL_LINE
-#endif
     }
-#if BOOST_LOCALE_ICU_VERSION >= 402
     TEST_FORMAT_CLS("{1,cur=nat}", 1234, "$1,234.00");
     TEST_FORMAT_CLS("{1,cur=national}", 1234, "$1,234.00");
     TEST_FORMAT_CLS("{1,cur=iso}", 1234, get_icu_currency_iso(1234));
-#endif
     TEST_FORMAT_CLS("{1,spell}", 10, "ten");
     TEST_FORMAT_CLS("{1,spellout}", 10, "ten");
-#if 402 <= BOOST_LOCALE_ICU_VERSION && BOOST_LOCALE_ICU_VERSION < 408
+#if BOOST_LOCALE_ICU_VERSION < 408
     if(charset == "UTF-8") {
         TEST_FORMAT_CLS("{1,ord}", 1, "1\xcb\xa2\xe1\xb5\x97");
         TEST_FORMAT_CLS("{1,ordinal}", 1, "1\xcb\xa2\xe1\xb5\x97");