Backport to C++20

Author: Joy-less

README.md

@@ -57,9 +57,10 @@ std::string element = jsonh_cpp::jsonh_reader::parse_element<std::string>(jsonh)
 
 ## Dependencies
 
+- C++20
 - [nlohmann/json](https://github.com/nlohmann/json) (up-to-date 2025/04/17)
 - [catchorg/Catch2](https://github.com/catchorg/Catch2) ([help](https://stackoverflow.com/a/78804393)) (up-to-date 2025/04/17)
-- C++23
+- [zeus-cpp/expected](https://github.com/zeus-cpp/expected) (backport) (up-to-date 2025/04/18)
 
 ## Limitations
 
@@ -80,8 +81,4 @@ Numbers are parsed as `long long` and `long double`, which correspond to 64-bit
 ### No token streaming
 
 While tokens can be read one by one from a stream, the tokens are aggregated in a `std::vector`
-before returning due to a lack of `yield` in C++.
-
-### C++23 or higher
-
-Since the library makes use of `std::expected`, you must build it with a C++23-compatible compiler.
+before returning due to a lack of `yield` in C++.

jsonh_cpp/backports.hpp

@@ -0,0 +1,11 @@
+// <expected> backport
+#ifdef __cpp_lib_expected
+#include <expected> // for std::expected
+#define JSONH_CPP_EXPECTED std::expected
+#define JSONH_CPP_UNEXPECTED std::unexpected
+#endif
+#ifndef __cpp_lib_expected
+#include "zeus/expected.hpp" // for zeus::expected
+#define JSONH_CPP_EXPECTED zeus::expected
+#define JSONH_CPP_UNEXPECTED zeus::unexpected
+#endif

jsonh_cpp/jsonh_cpp.vcxproj

@@ -112,7 +112,7 @@
       <ConformanceMode>true</ConformanceMode>
       <PrecompiledHeader>NotUsing</PrecompiledHeader>
       <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
-      <LanguageStandard>stdcpp23</LanguageStandard>
+      <LanguageStandard>stdcpp20</LanguageStandard>
       <LanguageStandard_C>stdc17</LanguageStandard_C>
       <GenerateXMLDocumentationFiles>true</GenerateXMLDocumentationFiles>
       <AdditionalOptions>/utf-8</AdditionalOptions>
@@ -144,13 +144,15 @@
   </ItemDefinitionGroup>
   <ItemGroup>
     <ClCompile Include="jsonh_reader.hpp" />
+    <ClInclude Include="backports.hpp" />
     <ClInclude Include="jsonh_cpp.hpp" />
     <ClInclude Include="jsonh_number_parser.hpp" />
     <ClInclude Include="jsonh_reader_options.hpp" />
     <ClInclude Include="jsonh_token.hpp" />
     <ClInclude Include="jsonh_token_type.hpp" />
     <ClInclude Include="nlohmann\json.hpp" />
     <ClInclude Include="utf8_reader.hpp" />
+    <ClInclude Include="zeus\expected.hpp" />
   </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">

jsonh_cpp/jsonh_cpp.vcxproj.filters

@@ -41,5 +41,11 @@
     <ClInclude Include="utf8_reader.hpp">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="zeus\expected.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="backports.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
 </Project>

jsonh_cpp/jsonh_number_parser.hpp

@@ -3,6 +3,7 @@
 #include <string> // for std::string
 #include <expected> // for std::expected
 #include <cmath> // for pow
+#include "backports.hpp" // for backport macros
 
 namespace jsonh_cpp {
 
@@ -17,7 +18,7 @@ class jsonh_number_parser final {
     /// Input: <c>+5.2e3.0</c><br/>
     /// Output: <c>5200</c>
     /// </summary>
-    static std::expected<long double, std::string> parse(std::string jsonh_number) noexcept {
+    static JSONH_CPP_EXPECTED<long double, std::string> parse(std::string jsonh_number) noexcept {
         // Decimal
         std::string base_digits = "0123456789";
         // Hexadecimal
@@ -47,7 +48,7 @@ class jsonh_number_parser final {
     /// <summary>
     /// Converts a fractional number with an exponent (e.g. <c>12.3e4.5</c>) from the given base (e.g. <c>01234567</c>) to a base-10 real.
     /// </summary>
-    static std::expected<long double, std::string> parse_fractional_number_with_exponent(std::string_view digits, std::string_view base_digits) noexcept {
+    static JSONH_CPP_EXPECTED<long double, std::string> parse_fractional_number_with_exponent(std::string_view digits, std::string_view base_digits) noexcept {
         // Find exponent
         size_t exponent_index = digits.find_first_of("eE");
         // If no exponent then normalize real
@@ -60,13 +61,13 @@ class jsonh_number_parser final {
         std::string_view exponent_part = digits.substr(exponent_index + 1);
 
         // Parse mantissa and exponent
-        std::expected<long double, std::string> mantissa = parse_fractional_number(mantissa_part, base_digits);
+        JSONH_CPP_EXPECTED<long double, std::string> mantissa = parse_fractional_number(mantissa_part, base_digits);
         if (!mantissa) {
-            return std::unexpected(mantissa.error());
+            return JSONH_CPP_UNEXPECTED(mantissa.error());
         }
-        std::expected<long double, std::string> exponent = parse_fractional_number(exponent_part, base_digits);
+        JSONH_CPP_EXPECTED<long double, std::string> exponent = parse_fractional_number(exponent_part, base_digits);
         if (!exponent) {
-            return std::unexpected(exponent.error());
+            return JSONH_CPP_UNEXPECTED(exponent.error());
         }
 
         // Multiply mantissa by 10 ^ exponent
@@ -75,7 +76,7 @@ class jsonh_number_parser final {
     /// <summary>
     /// Converts a fractional number (e.g. <c>123.45</c>) from the given base (e.g. <c>01234567</c>) to a base-10 real.
     /// </summary>
-    static std::expected<long double, std::string> parse_fractional_number(std::string_view digits, std::string_view base_digits) noexcept {
+    static JSONH_CPP_EXPECTED<long double, std::string> parse_fractional_number(std::string_view digits, std::string_view base_digits) noexcept {
         // Optimization for base-10 digits
         if (base_digits == "0123456789") {
             return std::stold(std::string(digits));
@@ -85,9 +86,9 @@ class jsonh_number_parser final {
         size_t dot_index = digits.find('.');
         // If no dot then normalize integer
         if (dot_index == std::string::npos) {
-            std::expected<long long, std::string> integer = parse_whole_number(digits, base_digits);
+            JSONH_CPP_EXPECTED<long long, std::string> integer = parse_whole_number(digits, base_digits);
             if (!integer) {
-                return std::unexpected(integer.error());
+                return JSONH_CPP_UNEXPECTED(integer.error());
             }
             return (long double)integer.value();
         }
@@ -97,13 +98,13 @@ class jsonh_number_parser final {
         std::string_view fraction_part = digits.substr(dot_index + 1);
 
         // Parse parts of number
-        std::expected<long long, std::string> whole = parse_whole_number(whole_part, base_digits);
+        JSONH_CPP_EXPECTED<long long, std::string> whole = parse_whole_number(whole_part, base_digits);
         if (!whole) {
-            return std::unexpected(whole.error());
+            return JSONH_CPP_UNEXPECTED(whole.error());
         }
-        std::expected<long long, std::string> fraction = parse_whole_number(fraction_part, base_digits);
+        JSONH_CPP_EXPECTED<long long, std::string> fraction = parse_whole_number(fraction_part, base_digits);
         if (!fraction) {
-            return std::unexpected(fraction.error());
+            return JSONH_CPP_UNEXPECTED(fraction.error());
         }
 
         // Combine whole and fraction
@@ -112,7 +113,7 @@ class jsonh_number_parser final {
     /// <summary>
     /// Converts a whole number (e.g. <c>12345</c>) from the given base (e.g. <c>01234567</c>) to a base-10 integer.
     /// </summary>
-    static std::expected<long long, std::string> parse_whole_number(std::string_view digits, std::string_view base_digits) noexcept {
+    static JSONH_CPP_EXPECTED<long long, std::string> parse_whole_number(std::string_view digits, std::string_view base_digits) noexcept {
         // Optimization for base-10 digits
         if (base_digits == "0123456789") {
             return std::stoll(digits.data());
@@ -138,7 +139,7 @@ class jsonh_number_parser final {
 
             // Ensure digit is valid
             if (digit_int == std::string::npos) {
-                return std::unexpected("Invalid digit");
+                return JSONH_CPP_UNEXPECTED("Invalid digit");
             }
 
             // Get magnitude of current digit column