Merge pull request #54 from zrax/cxx14

Increase minimum C++ standard to C++14

Author: zrax

CMakeLists.txt

@@ -22,7 +22,7 @@ cmake_minimum_required(VERSION 3.14 FATAL_ERROR)
 project(string_theory)
 
 # We will detect and use optional features in newer C++ standards,
-# but C++11 is required at minimum
+# but C++14 is required at minimum
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED OFF)
 set(CMAKE_CXX_EXTENSIONS OFF)
@@ -60,8 +60,6 @@ try_compile(ST_HAVE_CXX20_CHAR8_TYPES "${PROJECT_BINARY_DIR}"
             "${PROJECT_SOURCE_DIR}/cmake/check_char8_types.cpp")
 try_compile(ST_HAVE_INT64 "${PROJECT_BINARY_DIR}"
             "${PROJECT_SOURCE_DIR}/cmake/check_int64.cpp")
-try_compile(ST_HAVE_DEPRECATED_ATTR "${PROJECT_BINARY_DIR}"
-            "${PROJECT_SOURCE_DIR}/cmake/check_deprecated_attr.cpp")
 try_compile(ST_HAVE_NODISCARD_ATTR "${PROJECT_BINARY_DIR}"
             "${PROJECT_SOURCE_DIR}/cmake/check_nodiscard.cpp")
 

README.md

@@ -119,7 +119,7 @@ string_theory supports a variety of platforms and compilers.  As of March
 - MinGW-w64 GCC 8 (x86_64)
 
 As of string_theory 3.0, support for some older compilers has been dropped.
-You'll need a compiler that supports most of C++11.
+You'll need a compiler that supports C++14 or later.
 
 Contributing to String Theory
 -----------------------------

cmake/check_deprecated_attr.cpp

@@ -27,9 +27,6 @@
 #define ST_VERSION_STR "@ST_VERSION@"
 
 #cmakedefine ST_HAVE_INT64
-#if (__cplusplus > 201103L) || (defined(_MSVC_LANG) && (_MSVC_LANG > 201103L))
-#cmakedefine ST_HAVE_DEPRECATED_ATTR
-#endif
 #if (__cplusplus > 201402L) || (defined(_MSVC_LANG) && (_MSVC_LANG > 201402L))
 #cmakedefine ST_HAVE_NODISCARD_ATTR
 #cmakedefine ST_HAVE_CXX17_STRING_VIEW
@@ -62,16 +59,6 @@
     ST_AVAILABILITY(tvos,strict,introduced=13.0) \
     ST_AVAILABILITY(watchos,strict,introduced=6.0)
 
-#if defined(_MSC_VER)
-#   define ST_DEPRECATED(message) __declspec(deprecated(message))
-#elif defined(__GNUC__)
-#   define ST_DEPRECATED(message) __attribute__((deprecated(message)))
-#elif defined(ST_HAVE_DEPRECATED_ATTR)
-#   define ST_DEPRECATED(message) [[deprecated(message)]]
-#else
-#   define ST_DEPRECATED(message)
-#endif
-
 #ifndef ST_DEPRECATED_VERSION
 #   if defined(ST_NO_3_0_DEPRECATION)
 #       define ST_DEPRECATED_VERSION    299
@@ -81,19 +68,19 @@
 #endif
 
 #if ST_DEPRECATED_VERSION >= 300
-#   define ST_DEPRECATED_IN_3_0(message) ST_DEPRECATED(message)
+#   define ST_DEPRECATED_IN_3_0(message) [[deprecated(message)]]
 #else
 #   define ST_DEPRECATED_IN_3_0(message)
 #endif
 
 #if ST_DEPRECATED_VERSION >= 304
-#   define ST_DEPRECATED_IN_3_4(message) ST_DEPRECATED(message)
+#   define ST_DEPRECATED_IN_3_4(message) [[deprecated(message)]]
 #else
 #   define ST_DEPRECATED_IN_3_4(message)
 #endif
 
 #if ST_DEPRECATED_VERSION >= 400
-#   define ST_DEPRECATED_IN_4_0(message) ST_DEPRECATED(message)
+#   define ST_DEPRECATED_IN_4_0(message) [[deprecated(message)]]
 #else
 #   define ST_DEPRECATED_IN_4_0(message)
 #endif

include/st_config.h.in

@@ -47,7 +47,7 @@ namespace _ST_PRIVATE
         }
 
         ST_NODISCARD
-        ST::string to_string(bool utf8_encoded, ST::utf_validation_t validation)
+        ST::string to_string(bool utf8_encoded, ST::utf_validation_t validation) const
         {
             return m_output.to_string(utf8_encoded, validation);
         }

include/st_format.h

@@ -98,7 +98,7 @@ namespace ST
 
         void format(float_T value, char format)
         {
-            static const char valid_formats[] = "efgEFG";
+            static constexpr const char valid_formats[] = "efgEFG";
             if (!std::char_traits<char>::find(valid_formats, sizeof(valid_formats) - 1, format))
                 throw ST::bad_format("Unsupported floating-point format specifier");
 

include/st_format_numeric.h

@@ -123,7 +123,7 @@ namespace _ST_PRIVATE
     void format_numeric_s(const ST::format_spec &format,
                           ST::format_writer &output, int_T value)
     {
-        static_assert(std::is_signed<int_T>::value,
+        static_assert(std::is_signed_v<int_T>,
                       "Use _format_numeric_u for unsigned numerics");
 
         int radix = 10;
@@ -148,7 +148,7 @@ namespace _ST_PRIVATE
             ST_ASSERT(false, "Invalid digit class for _format_numeric_s");
         }
 
-        typedef typename std::make_unsigned<int_T>::type uint_T;
+        typedef std::make_unsigned_t<int_T> uint_T;
         ST::uint_formatter<uint_T> formatter;
         formatter.format(static_cast<uint_T>(std::abs(value)), radix, upper_case);
 
@@ -163,7 +163,7 @@ namespace _ST_PRIVATE
     void format_numeric_u(const ST::format_spec &format,
                           ST::format_writer &output, uint_T value)
     {
-        static_assert(std::is_unsigned<uint_T>::value,
+        static_assert(std::is_unsigned_v<uint_T>,
                       "Use _format_numeric_s for signed numerics");
 
         int radix = 10;
@@ -209,7 +209,8 @@ namespace _ST_PRIVATE
         if (error != conversion_error_t::success)
             append_chars(dest, badchar_substitute_utf8, badchar_substitute_utf8_len);
 
-        ST_ASSERT(size_t(dest - utf8) <= sizeof(utf8), "Destination buffer too small");
+        ST_ASSERT(static_cast<size_t>(dest - utf8) <= sizeof(utf8),
+                  "Destination buffer too small");
 
         output.append(utf8, dest - utf8);
     }

include/st_format_priv.h

@@ -91,7 +91,7 @@ namespace ST
         bool numeric_pad;
     };
 
-    static_assert(std::is_standard_layout<ST::format_spec>::value,
+    static_assert(std::is_standard_layout_v<ST::format_spec>,
                   "ST::format_spec must be standard-layout to pass across the DLL boundary");
 
     class format_writer
@@ -479,7 +479,7 @@ namespace ST
     inline void format_type(const ST::format_spec &format, ST::format_writer &output,
                             float value)
     {
-        format_type(format, output, double(value));
+        format_type(format, output, static_cast<double>(value));
     }
 
     template<typename value_T>

include/st_formatter.h

@@ -38,30 +38,30 @@ namespace _ST_PRIVATE
             : ST::format_writer(format_str), m_stream(stream) { }
 
         template <class write_char_T>
-        typename std::enable_if<std::is_same<write_char_T, char>::value, void>::type
+        std::enable_if_t<std::is_same_v<write_char_T, char>, void>
         write_data(const char *data, size_t size)
         {
             m_stream.write(data, size);
         }
 
         template <class write_char_T>
-        typename std::enable_if<std::is_same<write_char_T, wchar_t>::value, void>::type
+        std::enable_if_t<std::is_same_v<write_char_T, wchar_t>, void>
         write_data(const char *data, size_t size)
         {
             ST::wchar_buffer wide = ST::utf8_to_wchar(data, size);
             m_stream.write(wide.data(), wide.size());
         }
 
         template <class write_char_T>
-        typename std::enable_if<std::is_same<write_char_T, char16_t>::value, void>::type
+        std::enable_if_t<std::is_same_v<write_char_T, char16_t>, void>
         write_data(const char *data, size_t size)
         {
             ST::utf16_buffer utf16 = ST::utf8_to_utf16(data, size);
             m_stream.write(utf16.data(), utf16.size());
         }
 
         template <class write_char_T>
-        typename std::enable_if<std::is_same<write_char_T, char32_t>::value, void>::type
+        std::enable_if_t<std::is_same_v<write_char_T, char32_t>, void>
         write_data(const char *data, size_t size)
         {
             ST::utf32_buffer utf32 = ST::utf8_to_utf32(data, size);

include/st_iostream.h

@@ -69,7 +69,7 @@ namespace ST
         friend class string;
     };
 
-    static_assert(std::is_standard_layout<ST::conversion_result>::value,
+    static_assert(std::is_standard_layout_v<ST::conversion_result>,
                   "ST::conversion_result must be standard-layout to pass across the DLL boundary");
 
     class string
@@ -2373,7 +2373,7 @@ namespace ST
         ST_NODISCARD
         string replace(const char8_t *from, const string &to,
                        case_sensitivity_t cs = case_sensitive,
-                       utf_validation_t validation = ST_DEFAULT_VALIDATION)
+                       utf_validation_t validation = ST_DEFAULT_VALIDATION) const
         {
             return replace(from ? string(from, ST_AUTO_SIZE, validation) : string(), to, cs);
         }
@@ -2545,7 +2545,7 @@ namespace ST
         }
     };
 
-    static_assert(std::is_standard_layout<ST::string>::value,
+    static_assert(std::is_standard_layout_v<ST::string>,
                   "ST::string must be standard-layout to pass across the DLL boundary");
 
     struct hash