to_daw_json_string.h

Go to the documentation of this file.

// Copyright (c) Darrell Wright
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE or copy at http://www.boost.org/LICENSE_1_0.txt)
//
// Official repository: https://github.com/beached/daw_json_link
//
 
#pragma once
 
#include "daw/json/impl/version.h"
 
#include "daw/json/daw_json_data_contract.h"
#include "daw/json/impl/daw_json_assert.h"
#include "daw/json/impl/daw_json_parse_iso8601_utils.h"
#include "daw/json/impl/daw_json_serialize_options_impl.h"
#include "daw/json/impl/daw_json_serialize_policy.h"
#include "daw/json/impl/daw_json_value.h"
 
#include <daw/daw_algorithm.h>
#include <daw/traits/daw_traits_is_explicitly_convertible.h>
#include <daw/daw_arith_traits.h>
#include <daw/daw_callable.h>
#include <daw/daw_constant.h>
#include <daw/daw_cpp_feature_check.h>
#include <daw/daw_cxmath.h>
#include <daw/daw_enable_requires.h>
#include <daw/daw_likely.h>
#include <daw/daw_move.h>
#include <daw/daw_simple_array.h>
#include <daw/daw_traits.h>
#include <daw/daw_utility.h>
#include <daw/daw_visit.h>
#include <daw/third_party/dragonbox/dragonbox.h>
#include <daw/utf8/unchecked.h>
 
#include <array>
#if defined( DAW_HAS_CPP20_CONCEPTS )
#include <concepts>
#endif
#include <daw/stdinc/move_fwd_exch.h>
#include <daw/stdinc/tuple_traits.h>
#include <optional>
#include <sstream>
#include <string>
#include <string_view>
#include <type_traits>
#include <variant>
 
namespace daw::json {
  inline namespace DAW_JSON_VER {
    namespace json_details {
      template<options::FPOutputFormat fp_output_format,
               unsigned Precision = daw::max_value<unsigned>, typename Real,
               typename WriteableType>
      constexpr WriteableType to_chars( Real const &value,
                                        WriteableType out_it );
    } // namespace json_details
 
    namespace json_details::to_strings {
      using std::to_string;
      // Need to use ADL to_string in unevaluated contexts.  Limiting to it's
      // own namespace
      template<typename T>
      [[nodiscard]] static constexpr auto to_string( std::optional<T> const &v )
        -> decltype( to_string( *v ) ) {
        if( not has_value( v ) ) {
          return { "null" };
        }
        return to_string( *v );
      }
 
      DAW_JSON_MAKE_REQ_TRAIT( has_to_string_v,
                               to_string( std::declval<T>( ) ) );
 
    } // namespace json_details::to_strings
    namespace json_details {
      DAW_JSON_MAKE_REQ_TRAIT(
        has_from_string_v, from_string( std::declval<daw::tag_t<T>>( ),
                                        std::declval<std::string_view>( ) ) );
 
      DAW_JSON_MAKE_REQ_TRAIT(
        has_ostream_op_v, operator<<( std::declval<std::stringstream &>( ),
                                      std::declval<T const &>( ) ) );
 
      DAW_JSON_MAKE_REQ_TRAIT(
        has_istream_op_v, operator>>( std::declval<std::stringstream &>( ),
                                      std::declval<T const &>( ) ) );
    } // namespace json_details
 
    /***
     * This is the default ToJsonConverter for json_custom. By default is will
     * return the stringified version of the value if, to_string( T ) exists.
     * Otherwise it will fallback to an std::ostream converter for T if it
     * exists.
     * @tparam T type of value to convert to a string
     */
    template<typename T>
    struct default_to_json_converter_t {
      template<typename U>
      [[nodiscard]] static std::string use_stream( U const &v ) {
        std::stringstream ss{ };
        ss << v;
        return std::move( ss ).str( );
      }
 
      template<typename U>
      [[nodiscard]] DAW_JSON_CPP23_STATIC_CALL_OP constexpr auto
      operator( )( U const &value ) DAW_JSON_CPP23_STATIC_CALL_OP_CONST {
        if constexpr( json_details::is_string_view_like_v<U> ) {
          return std::string_view( std::data( value ), std::size( value ) );
        } else if constexpr( json_details::to_strings::has_to_string_v<U> ) {
          using json_details::to_strings::to_string;
          return to_string( value );
        } else if constexpr( json_details::has_ostream_op_v<U> ) {
          return use_stream( value );
        } else if constexpr( std::is_convertible_v<U, std::string_view> ) {
          return static_cast<std::string_view>( value );
        } else if constexpr( std::is_convertible_v<U, std::string> ) {
          return static_cast<std::string>( value );
        } else if constexpr( daw::is_arithmetic_v<U> ) {
          return to_string( value );
        } else if constexpr( std::is_enum_v<U> ) {
          return to_string( static_cast<std::underlying_type_t<U>>( value ) );
        } else if constexpr( concepts::is_nullable_value_v<U> ) {
          using value_type = concepts::nullable_value_type_t<U>;
          if constexpr( json_details::is_string_view_like_v<value_type> ) {
            if constexpr( std::is_reference_v<DAW_TYPEOF(
                            concepts::nullable_value_read( value ) )> ) {
              if( concepts::nullable_value_has_value( value ) ) {
                return daw::string_view(
                  concepts::nullable_value_read( value ) );
              }
              return daw::string_view( "null" );
            } else {
              if( concepts::nullable_value_has_value( value ) ) {
                auto const &v = concepts::nullable_value_read( value );
                return std::string( std::data( v ), std::size( v ) );
              }
              return std::string( "null", 4 );
            }
          } else if constexpr( json_details::to_strings::has_to_string_v<
                                 value_type> ) {
            if( concepts::nullable_value_has_value( value ) ) {
              using json_details::to_strings::to_string;
              return to_string( concepts::nullable_value_read( value ) );
            } else {
              using result_t = DAW_TYPEOF(
                to_string( concepts::nullable_value_read( value ) ) );
              return result_t{ "null" };
            }
          } else if constexpr( std::is_convertible_v<value_type,
                                                     std::string_view> ) {
            if( concepts::nullable_value_has_value( value ) ) {
              return static_cast<std::string_view>(
                concepts::nullable_value_read( value ) );
            }
            return std::string_view{ "null" };
          } else if constexpr( std::is_convertible_v<value_type,
                                                     std::string> ) {
            if( concepts::nullable_value_has_value( value ) ) {
              return static_cast<std::string>(
                concepts::nullable_value_read( value ) );
            }
            return std::string( "null" );
          } else {
            if( concepts::nullable_value_has_value( value ) ) {
              return use_stream( concepts::nullable_value_has_value( value ) );
            } else {
              return std::string( "null" );
            }
          }
        }
      }
    };
 
    namespace from_json_conv_details {
      template<typename T>
      [[nodiscard]] static auto use_stream( std::string_view sv ) {
        std::stringstream ss{ };
        ss << sv;
        T result;
        ss >> result;
        return result;
      }
    } // namespace from_json_conv_details
 
    template<typename T>
    struct default_from_json_converter_t {
      [[nodiscard]] DAW_JSON_CPP23_STATIC_CALL_OP constexpr decltype( auto )
      operator( )( std::string_view sv ) DAW_JSON_CPP23_STATIC_CALL_OP_CONST {
        if constexpr( std::is_same_v<T, std::string_view> or
                      std::is_same_v<T, std::optional<std::string_view>> ) {
          return sv;
        } else if constexpr( json_details::has_from_string_v<T> ) {
          return from_string( daw::tag<T>, sv );
        } else if constexpr( std::is_convertible_v<std::string_view, T> ) {
          return static_cast<T>( sv );
        } else if constexpr( std::is_convertible_v<std::string, T> ) {
          return static_cast<T>( static_cast<std::string>( sv ) );
        } else {
          static_assert( json_details::has_istream_op_v<T>,
                         "Unsupported type in default to converter.  Must "
                         "supply a custom one" );
          static_assert( std::is_default_constructible_v<T>,
                         "Unsupported type in default to converter.  Must "
                         "supply a custom one" );
          return from_json_conv_details::use_stream<T>( sv );
        }
      }
    };
 
    namespace json_details {
 
      template<typename Char>
      static constexpr char to_nibble_char( Char c ) {
        auto const u = static_cast<unsigned>( static_cast<unsigned char>( c ) );
        daw_json_ensure( u < 16, ErrorReason::InvalidUTFEscape );
        if( u < 10 ) {
          return static_cast<char>( u + static_cast<unsigned char>( '0' ) );
        } else {
          return static_cast<char>( ( u - 10U ) +
                                    static_cast<unsigned char>( 'A' ) );
        }
      }
 
      template<typename WritableType>
      static constexpr WritableType output_hex( std::uint16_t c,
                                                WritableType it ) {
        char const nibbles[] = { '\\',
                                 'u',
                                 to_nibble_char( ( c >> 12U ) & 0xFU ),
                                 to_nibble_char( ( c >> 8U ) & 0xFU ),
                                 to_nibble_char( ( c >> 4U ) & 0xFU ),
                                 to_nibble_char( c & 0xFU ),
                                 '\0' };
 
        it.write( nibbles );
        return it;
      }
 
      template<typename WritableType>
      static constexpr void utf32_to_utf8( std::uint32_t cp,
                                           WritableType &it ) {
        if( cp <= 0x7FU ) {
          it.put( static_cast<char>( cp ) );
          return;
        }
        if( cp <= 0x7FFU ) {
          char const tmp[] = {
            static_cast<char>( ( cp >> 6U ) | 0b11000000U ),
            static_cast<char>( ( cp & 0b00111111U ) | 0b10000000U ),
            '\0' };
          it.write( tmp );
          return;
        }
        if( cp <= 0xFFFFU ) {
          char const tmp[]{
            static_cast<char>( ( cp >> 12U ) | 0b11100000U ),
            static_cast<char>( ( ( cp >> 6U ) & 0b00111111U ) | 0b10000000U ),
            static_cast<char>( ( cp & 0b00111111U ) | 0b10000000U ),
            '\0' };
          it.write( tmp );
          return;
        }
        if( cp <= 0x10FFFFU ) {
          char const tmp[]{
            static_cast<char>( ( cp >> 18U ) | 0b11110000U ),
            static_cast<char>( ( ( cp >> 12U ) & 0b00111111U ) | 0b10000000U ),
            static_cast<char>( ( ( cp >> 6U ) & 0b00111111U ) | 0b10000000U ),
            static_cast<char>( ( cp & 0b00111111U ) | 0b10000000U ),
            '\0' };
          it.write( tmp );
          return;
        }
        daw_json_error( true, ErrorReason::InvalidUTFCodepoint );
      }
    } // namespace json_details
 
    namespace utils {
      template<bool RestrictHigh, typename WriteableType>
      [[nodiscard]] static constexpr WriteableType
      escape_codepoint_to_iterator( WriteableType it, std::uint32_t cp ) {
        switch( cp ) {
        case '"':
          it.write( "\\\"" );
          break;
        case '\\':
          it.write( "\\\\" );
          break;
        case '\b':
          it.write( "\\b" );
          break;
        case '\f':
          it.write( "\\f" );
          break;
        case '\n':
          it.write( "\\n" );
          break;
        case '\r':
          it.write( "\\r" );
          break;
        case '\t':
          it.write( "\\t" );
          break;
        default:
          if( cp < 0x20U ) {
            it =
              json_details::output_hex( static_cast<std::uint16_t>( cp ), it );
            break;
          }
          if constexpr( RestrictHigh ) {
            if( cp >= 0x80U and cp <= 0xFFFFU ) {
              it = json_details::output_hex( static_cast<std::uint16_t>( cp ),
                                             it );
              break;
            }
            if( cp > 0xFFFFU ) {
              it = json_details::output_hex(
                static_cast<std::uint16_t>( 0xD7C0U + ( cp >> 10U ) ), it );
              it = json_details::output_hex(
                static_cast<std::uint16_t>( 0xDC00U + ( cp & 0x3FFU ) ), it );
              break;
            }
          }
          json_details::utf32_to_utf8( cp, it );
          break;
        }
        return it;
      }
 
      template<
        bool do_escape = false,
        options::EightBitModes EightBitMode = options::EightBitModes::AllowFull,
        bool use_scanned_write = false, typename WritableType,
        typename Container DAW_ENABLEIF(
          daw::traits::is_container_like_v<daw::remove_cvref_t<Container>> )>
      DAW_REQUIRES(
        daw::traits::is_container_like_v<daw::remove_cvref_t<Container>> )
      [[nodiscard]] static constexpr WritableType
        copy_to_iterator( WritableType it, Container const &container ) {
        using restrict_high = std::bool_constant<
          EightBitMode != options::EightBitModes::AllowFull or
          ( WritableType::restricted_string_output ==
            options::RestrictedStringOutput::OnlyAllow7bitStrings )>;
        if constexpr( do_escape ) {
          if constexpr( use_scanned_write and
                        json_details::is_string_view_like_v<Container> ) {
            auto const *const data = std::data( container );
            auto const size = std::size( container );
            bool is_ascii = true;
            for( std::size_t n = 0; n < size; ++n ) {
              if( static_cast<unsigned char>( data[n] ) >= 0x80U ) {
                is_ascii = false;
                break;
              }
            }
            if( is_ascii ) {
              auto const *first = data;
              auto const *pos = data;
              auto const *const last = data + size;
              while( pos != last ) {
                auto const c = static_cast<unsigned char>( *pos );
                if( c != '"' and c != '\\' and c >= 0x20U ) {
                  ++pos;
                  continue;
                }
                if( first != pos ) {
                  it.write( daw::string_view(
                    first, static_cast<std::size_t>( pos - first ) ) );
                }
                switch( c ) {
                case '"':
                  it.write( "\\\"" );
                  break;
                case '\\':
                  it.write( "\\\\" );
                  break;
                case '\b':
                  it.write( "\\b" );
                  break;
                case '\f':
                  it.write( "\\f" );
                  break;
                case '\n':
                  it.write( "\\n" );
                  break;
                case '\r':
                  it.write( "\\r" );
                  break;
                case '\t':
                  it.write( "\\t" );
                  break;
                default:
                  it = json_details::output_hex(
                    static_cast<std::uint16_t>( c ), it );
                  break;
                }
                ++pos;
                first = pos;
              }
              if( first != last ) {
                it.write( daw::string_view(
                  first, static_cast<std::size_t>( last - first ) ) );
              }
              return it;
            }
          }
          using iter = DAW_TYPEOF( std::begin( container ) );
          using it_t = utf8::unchecked::iterator<iter>;
 
          auto first = it_t( std::begin( container ) );
          auto const last = it_t( std::end( container ) );
          while( first != last ) {
            auto const last_it = first;
            auto const cp = *first++;
            if( last_it == first ) {
              // Not a valid unicode cp
              if constexpr( WritableType::restricted_string_output ==
                            options::RestrictedStringOutput::
                              ErrorInvalidUTF8 ) {
                daw_json_error( true, ErrorReason::InvalidStringHighASCII );
              } else {
                first = it_t( std::next( first.base( ) ) );
              }
            }
            it = escape_codepoint_to_iterator<restrict_high::value>( it, cp );
          }
        } else {
          if constexpr( json_details::is_string_view_like_v<Container> ) {
            if constexpr( restrict_high::value ) {
              for( auto c : container ) {
                daw_json_ensure( ( static_cast<unsigned char>( c ) >= 0x20U and
                                   static_cast<unsigned char>( c ) <= 0x7FU ),
                                 ErrorReason::InvalidStringHighASCII );
              }
            }
            it.write( daw::string_view( std::data( container ),
                                        std::size( container ) ) );
          } else {
            for( auto c : container ) {
              if constexpr( restrict_high::value ) {
                daw_json_ensure( ( static_cast<unsigned char>( c ) >= 0x20U and
                                   static_cast<unsigned char>( c ) <= 0x7FU ),
                                 ErrorReason::InvalidStringHighASCII );
              }
              it.put( c );
            }
          }
        }
        return it;
      }
 
      template<
        bool do_escape = false,
        options::EightBitModes EightBitMode = options::EightBitModes::AllowFull,
        typename WriteableType>
      [[nodiscard]] static constexpr WriteableType
      copy_to_iterator( WriteableType it, char const *ptr ) {
        if( ptr == nullptr ) {
          return it;
        }
        using restrict_high = std::bool_constant<
          EightBitMode != options::EightBitModes::AllowFull or
          ( WriteableType::restricted_string_output ==
            options::RestrictedStringOutput::OnlyAllow7bitStrings )>;
 
        if constexpr( do_escape ) {
          auto chr_it = utf8::unchecked::iterator<char const *>( ptr );
          while( *chr_it.base( ) != '\0' ) {
            auto const cp = *chr_it++;
            it = escape_codepoint_to_iterator<restrict_high::value>( it, cp );
          }
        } else if constexpr( restrict_high::value ) {
          auto const *const first = ptr;
          while( *ptr != '\0' ) {
            daw_json_ensure( ( static_cast<unsigned char>( *ptr ) >= 0x20U and
                               static_cast<unsigned char>( *ptr ) <= 0x7FU ),
                             ErrorReason::InvalidStringHighASCII );
            ++ptr;
          }
          it.write( daw::string_view(
            first, static_cast<std::size_t>( ptr - first ) ) );
        } else {
          it.write( ptr );
        }
        return it;
      }
 
      template<
        bool do_escape = false,
        options::EightBitModes EightBitMode = options::EightBitModes::AllowFull,
        typename WriteableType, json_options_t P, typename A>
      [[nodiscard]] static constexpr WriteableType
      copy_to_iterator( WriteableType it, basic_json_value<P, A> const &jv ) {
        if( jv.is_null( ) ) {
          return copy_to_iterator<do_escape, EightBitMode>( it, "null" );
        } else {
          return copy_to_iterator<do_escape, EightBitMode>(
            it, jv.get_string_view( ) );
        }
      }
    } // namespace utils
 
    namespace json_details {
      template<typename JsonMember, JsonParseTypes Tag, typename WriteableType,
               typename parse_to_t>
      [[nodiscard]] DAW_ATTRIB_INLINE static constexpr WriteableType
      to_daw_json_string( WriteableType it, parse_to_t const &value );
 
      template<typename JsonMember, typename WriteableType, typename parse_to_t>
      [[nodiscard]] static constexpr WriteableType
      to_json_string_bool( WriteableType it, parse_to_t const &value ) {
 
        if constexpr( JsonMember::literal_as_string ==
                      options::LiteralAsStringOpt::Always ) {
          if( value ) {
            it.write( "\"true\"" );
          } else {
            it.write( "\"false\"" );
          }
        } else {
          if( value ) {
            it.write( "true" );
          } else {
            it.write( "false" );
          }
        }
        return it;
      }
 
      template<std::size_t idx, typename JsonMembers, typename WriteableType,
               typename parse_to_t>
      static constexpr void to_variant_string( WriteableType &it,
                                               parse_to_t const &value ) {
        if constexpr( idx < std::variant_size_v<parse_to_t> ) {
          if( value.index( ) != idx ) {
            to_variant_string<idx + 1, JsonMembers>( it, value );
            return;
          }
          using element_t = typename JsonMembers::json_elements;
          using JsonMember =
            typename pack_element<idx, typename element_t::element_map_t>::type;
          it = to_daw_json_string<JsonMember, JsonMember::expected_type>(
            it, daw::get_nt<idx>( value ) );
        }
      }
 
      template<typename JsonMember, typename WriteableType, typename parse_to_t>
      [[nodiscard]] static constexpr WriteableType
      to_json_string_variant( WriteableType it, parse_to_t const &value ) {
 
        assert( value.index( ) >= 0 );
        to_variant_string<0, JsonMember>( it, value );
        return it;
      }
 
      template<typename JsonMember, typename WriteableType, typename parse_to_t>
      [[nodiscard]] static constexpr WriteableType
      to_json_string_variant_tagged( WriteableType it,
                                     parse_to_t const &value ) {
 
        to_variant_string<0, JsonMember>( it, value );
        return it;
      }
 
      template<typename JsonMember, typename WriteableType, typename parse_to_t>
      [[nodiscard]] static constexpr WriteableType
      to_json_string_variant_intrusive( WriteableType it,
                                        parse_to_t const &value ) {
 
        to_variant_string<0, JsonMember>( it, value );
        return it;
      }
 
      template<typename /*JsonMember*/, typename = void>
      inline constexpr bool has_null_checker_v = false;
 
      template<typename JsonMember>
      inline constexpr bool has_null_checker_v<
        JsonMember, std::void_t<typename JsonMember::is_null_checker>> =
        not std::is_same_v<use_default, typename JsonMember::is_null_checker>;
 
      template<typename JsonMember, typename WriteableType, typename Optional>
      [[nodiscard]] static constexpr WriteableType
      to_json_string_null( WriteableType it, Optional const &value ) {
 
        if constexpr( has_null_checker_v<JsonMember> ) {
          // Null checker specified
          using is_null_checker_t = typename JsonMember::is_null_checker;
          if( is_null_checker_t{ }( value ) ) {
            it.write( "null" );
            return it;
          }
        } else if constexpr( has_op_bool_v<Optional> ) {
          if( not static_cast<bool>( value ) ) {
            it.write( "null" );
            return it;
          }
        } else {
          // has_value defaults to true for non-nullable.  This allows types
          // like containers to accept null/missing on parsing but just be empty
          // when serialized
          if( not concepts::nullable_value_has_value( value ) ) {
            it.write( "null" );
            return it;
          }
        }
        using member_type = typename JsonMember::member_type;
        return to_daw_json_string<member_type, member_type::expected_type>(
          it, [&] {
            if constexpr( concepts::is_nullable_value_v<Optional> ) {
              return concepts::nullable_value_traits<Optional>::read( value );
            } else if constexpr( json_details::has_op_star_v<Optional> ) {
              return *value;
            } else {
              return value;
            }
          }( ) );
      }
 
      DAW_JSON_MAKE_REQ_TRAIT( has_fp_precision_v, T::precision );
 
      template<typename JsonMember, typename WriteableType, typename parse_to_t>
      [[nodiscard]] static constexpr WriteableType
      to_json_string_real( WriteableType it, parse_to_t const &value ) {
 
        static_assert(
          std::is_convertible_v<parse_to_t, json_result_t<JsonMember>>,
          "value must be convertible to specified type in class contract" );
 
        if constexpr( std::is_floating_point_v<json_result_t<JsonMember>> ) {
          if( daw::cxmath::is_nan( value ) ) {
            if constexpr( JsonMember::literal_as_string ==
                            options::LiteralAsStringOpt::Never or
                          JsonMember::allow_number_errors ==
                            options::JsonNumberErrors::None or
                          JsonMember::allow_number_errors ==
                            options::JsonNumberErrors::AllowInf ) {
              daw_json_error( true, ErrorReason::NumberIsNaN );
            } else {
              it.write( "\"NaN\"" );
              return it;
            }
          } else if( daw::cxmath::is_inf( value ) ) {
            if constexpr( JsonMember::literal_as_string ==
                            options::LiteralAsStringOpt::Never or
                          JsonMember::allow_number_errors ==
                            options::JsonNumberErrors::None or
                          JsonMember::allow_number_errors ==
                            options::JsonNumberErrors::AllowNaN ) {
              daw_json_error( true, ErrorReason::NumberIsInf );
            } else {
              if( value < 0 ) {
                it.write( "\"-Infinity\"" );
              } else {
                it.write( "\"Infinity\"" );
              }
              return it;
            }
          }
        }
 
        if constexpr( JsonMember::literal_as_string ==
                      options::LiteralAsStringOpt::Always ) {
          it.put( '"' );
        }
        if constexpr( daw::is_floating_point_v<parse_to_t> ) {
          static_assert( sizeof( parse_to_t ) <= sizeof( double ) );
          if constexpr( has_fp_precision_v<JsonMember> ) {
            it = to_chars<JsonMember::fp_output_format, JsonMember::precision>(
              value, it );
          } else {
            it = to_chars<JsonMember::fp_output_format>( value, it );
          }
        } else {
          using std::to_string;
          using to_strings::to_string;
          it = utils::copy_to_iterator( it, to_string( value ) );
        }
        if constexpr( JsonMember::literal_as_string ==
                      options::LiteralAsStringOpt::Always ) {
          it.put( '"' );
        }
        return it;
      }
 
      template<typename T>
      using base_int_type_impl = std::underlying_type<T>;
 
      template<typename T>
      using base_int_type_t =
        typename daw::conditional_t<std::is_enum_v<T>, base_int_type_impl<T>,
                                    daw::traits::identity<T>>::type;
 
      DAW_ATTRIB_INLINE DAW_CONSTEVAL std::array<char[2], 100>
      make_digits100( ) {
        auto result = std::array<char[2], 100>{ };
        for( std::size_t n = 0; n < 100; ++n ) {
          result[n][0] =
            static_cast<char>( ( n % 10 ) + static_cast<unsigned char>( '0' ) );
          result[n][1] =
            static_cast<char>( ( n / 10 ) + static_cast<unsigned char>( '0' ) );
        }
        return result;
      }
      inline constexpr auto digits100 = make_digits100( );
 
      template<typename T>
      static constexpr void reverse( T *first, T *last ) {
        // Assume preconditions. This helps on CE in codegen but may
        // not matter here with inlining
        DAW_ASSUME( first and last );
        DAW_ASSUME( first <= last );
        auto rpos = last - first;
        auto lpos = 0;
        while( lpos < rpos ) {
          --rpos;
          auto tmp = std::move( first[lpos] );
          first[lpos] = std::move( first[rpos] );
          first[rpos] = std::move( tmp );
          ++lpos;
        }
      }
 
      template<typename JsonMember, typename WriteableType, typename parse_to_t>
      [[nodiscard]] static constexpr WriteableType
      to_json_string_signed( WriteableType it, parse_to_t const &value ) {
 
        static_assert(
          daw::is_explicitly_convertible_v<parse_to_t,
                                           json_base_type_t<JsonMember>>,
          "value must be convertible to specified type in class contract" );
 
        using std::to_string;
        using to_strings::to_string;
        using under_type = base_int_type_t<parse_to_t>;
 
        if constexpr( std::is_enum_v<parse_to_t> or
                      daw::is_integral_v<parse_to_t> ) {
          auto v = static_cast<under_type>( value );
 
          char buff[daw::digits10<under_type> + 10]{ };
          char *num_start = buff;
          char *ptr = buff;
          if constexpr( JsonMember::literal_as_string ==
                        options::LiteralAsStringOpt::Always ) {
            *ptr++ = '"';
            ++num_start;
          }
          if( v < 0 ) {
            *ptr++ = '-';
            ++num_start;
            // Do 1 round here just in case we are
            // daw::min_value<intmax_t> and cannot negate
            // This is a subtraction because when v < 0, v % 100 is negative
            auto const tmp = -static_cast<std::size_t>( v % 10 );
            v /= -10;
            *ptr++ = digits100[tmp][0];
            if( v == 0 ) {
              if constexpr( JsonMember::literal_as_string ==
                            options::LiteralAsStringOpt::Always ) {
                *ptr++ = '"';
              }
              it.copy_buffer( buff, ptr );
              return it;
            }
          }
 
          if( v == 0 ) {
            *ptr++ = '0';
          }
          while( v >= 10 ) {
            auto const tmp = static_cast<std::size_t>( v % 100 );
            v /= 100;
            ptr[0] = digits100[tmp][0];
            ptr[1] = digits100[tmp][1];
            ptr += 2;
          }
          if( v > 0 ) {
            *ptr++ = static_cast<char>( '0' + static_cast<char>( v ) );
          }
 
          reverse( num_start, ptr );
          if constexpr( JsonMember::literal_as_string ==
                        options::LiteralAsStringOpt::Always ) {
            *ptr++ = '"';
          }
          it.copy_buffer( buff, ptr );
          return it;
        } else {
          if constexpr( JsonMember::literal_as_string ==
                        options::LiteralAsStringOpt::Always ) {
            it.put( '"' );
          }
          // Fallback to ADL
          it = utils::copy_to_iterator( it, to_string( value ) );
          if constexpr( JsonMember::literal_as_string ==
                        options::LiteralAsStringOpt::Always ) {
            it.put( '"' );
          }
          return it;
        }
      }
 
      template<typename JsonMember, typename WriteableType, typename parse_to_t>
      [[nodiscard]] static constexpr WriteableType
      to_json_string_unsigned( WriteableType it, parse_to_t const &value ) {
 
        static_assert(
          daw::is_explicitly_convertible_v<parse_to_t,
                                           json_result_t<JsonMember>>,
          "value must be convertible to specified type in class contract" );
 
        using std::to_string;
        using to_strings::to_string;
        using under_type = base_int_type_t<parse_to_t>;
        if constexpr( JsonMember::literal_as_string ==
                      options::LiteralAsStringOpt::Always ) {
          it.put( '"' );
        }
        if constexpr( std::is_same_v<under_type, bool> ) {
          if( static_cast<bool>( value ) ) {
            it.put( '1' );
          } else {
            it.put( '0' );
          }
        } else if constexpr( std::is_enum_v<parse_to_t> or
                             daw::is_integral_v<parse_to_t> ) {
          auto v = static_cast<under_type>( value );
 
          if( DAW_UNLIKELY( v == 0 ) ) {
            it.put( '0' );
          } else {
            daw_json_ensure( v > 0, ErrorReason::NumberOutOfRange );
            char buff[daw::digits10<under_type> + 10U]{ };
            char *ptr = buff;
            while( v >= 10 ) {
              auto const tmp = static_cast<std::size_t>( v % 100U );
              v /= 100U;
              ptr[0] = digits100[tmp][0];
              ptr[1] = digits100[tmp][1];
              ptr += 2;
            }
            if( v > 0 ) {
              *ptr++ = static_cast<char>( '0' + static_cast<char>( v ) );
            }
            reverse( buff, ptr );
            it.copy_buffer( buff, ptr );
          }
        } else {
          // Fallback to ADL
          it = utils::copy_to_iterator( it, to_string( value ) );
        }
        if constexpr( JsonMember::literal_as_string ==
                      options::LiteralAsStringOpt::Always ) {
          it.put( '"' );
        }
        return it;
      }
    } // namespace json_details
 
    namespace utils {
      namespace utils_details {
        template<typename Integer>
        struct number {
          using parse_to_t = Integer;
          using base_type = parse_to_t;
          static constexpr options::LiteralAsStringOpt literal_as_string =
            options::LiteralAsStringOpt::Never;
        };
      } // namespace utils_details
 
      template<typename Integer, typename WriteableType>
      static constexpr WriteableType integer_to_string( WriteableType it,
                                                        Integer const &value ) {
        static_assert( daw::is_integral_v<Integer> );
 
        if constexpr( daw::is_unsigned_v<Integer> ) {
          return json_details::to_json_string_unsigned<
            utils_details::number<Integer>>( it, value );
        } else {
          return json_details::to_json_string_signed<
            utils_details::number<Integer>>( it, value );
        }
      }
    } // namespace utils
 
    namespace json_details {
      template<typename JsonMember, typename WriteableType, typename parse_to_t>
      [[nodiscard]] static constexpr WriteableType
      to_json_string_string_raw( WriteableType it, parse_to_t const &value ) {
 
        static_assert(
          std::is_convertible_v<parse_to_t, json_result_t<JsonMember>>,
          "Value must be convertible to specialized type in "
          "json_data_contract" );
 
        it.put( '"' );
        if( std::size( value ) > 0U ) {
          it = utils::copy_to_iterator<false, JsonMember::eight_bit_mode>(
            it, value );
        }
        it.put( '"' );
        return it;
      }
 
      template<typename JsonMember, typename = void>
      inline constexpr options::EscapeValidUTF8 escape_output_v =
        options::EscapeValidUTF8::Validate;
 
      template<typename JsonMember>
      inline constexpr options::EscapeValidUTF8 escape_output_v<
        JsonMember, std::void_t<decltype( JsonMember::escape_output )>> =
        JsonMember::escape_output;
 
      template<typename JsonMember, typename WriteableType, typename parse_to_t>
      [[nodiscard]] static constexpr WriteableType
      to_json_string_string_escaped( WriteableType it,
                                     parse_to_t const &value ) {
        it.put( '"' );
        it = utils::copy_to_iterator<escape_output_v<JsonMember> !=
                                       options::EscapeValidUTF8::AssumeValid,
                                     JsonMember::eight_bit_mode,
                                     true>( it, value );
        it.put( '"' );
        return it;
      }
 
      template<typename T>
      [[nodiscard]] static constexpr bool is_null( std::optional<T> const &v ) {
        return not static_cast<bool>( v );
      }
 
      template<typename T>
      [[nodiscard]] static constexpr bool is_null( T const & ) {
        return false;
      }
 
      template<typename JsonMember, typename WriteableType, typename parse_to_t>
      [[nodiscard]] static constexpr WriteableType
      to_json_string_date( WriteableType it, parse_to_t const &value ) {
 
        static_assert(
          std::is_convertible_v<parse_to_t, json_result_t<JsonMember>>,
          "value must be convertible to specified type in class contract" );
 
        using json_details::is_null;
        // TODO: document customization point
        if( is_null( value ) ) {
          it.write( "null" );
          return it;
        }
        it.put( '"' );
        datetime::ymdhms civil = datetime::time_point_to_civil( value );
        it = utils::integer_to_string( it, civil.year );
        it.put( '-' );
        if( civil.month < 10 ) {
          it.put( '0' );
        }
        it = utils::integer_to_string( it, civil.month );
        it.put( '-' );
        if( civil.day < 10 ) {
          it.put( '0' );
        }
        it = utils::integer_to_string( it, civil.day );
        it.put( 'T' );
        if( civil.hour < 10 ) {
          it.put( '0' );
        }
        it = utils::integer_to_string( it, civil.hour );
        it.put( ':' );
        if( civil.minute < 10 ) {
          it.put( '0' );
        }
        it = utils::integer_to_string( it, civil.minute );
        it.put( ':' );
        if( civil.second < 10 ) {
          it.put( '0' );
        }
        it = utils::integer_to_string( it, civil.second );
        if( civil.attosecond > 0 ) {
          auto fractional_digits = std::size_t{ 18 };
          while( civil.attosecond % 10 == 0 ) {
            civil.attosecond /= 10;
            --fractional_digits;
          }
          it.put( '.' );
          auto const digit_count = static_cast<std::size_t>(
            daw::cxmath::count_digits( civil.attosecond ) );
          while( digit_count < fractional_digits ) {
            it.put( '0' );
            --fractional_digits;
          }
          it = utils::integer_to_string( it, civil.attosecond );
        }
        it.write( "Z\"" );
        return it;
      }
 
      template<typename JsonMember, typename WriteableType, typename parse_to_t>
      [[nodiscard]] static constexpr WriteableType
      to_json_string_unknown( WriteableType it, parse_to_t const &value ) {
 
        return utils::copy_to_iterator<false, JsonMember::eight_bit_mode>(
          it, value );
      }
 
      template<typename JsonMember, typename WriteableType, typename parse_to_t>
      [[nodiscard]] static constexpr WriteableType
      to_json_string_class( WriteableType it, parse_to_t const &value ) {
 
        static_assert(
          std::is_convertible_v<parse_to_t, json_result_t<JsonMember>> or
            std::is_same_v<parse_to_t,
                           json_result_t<JsonMember>>, // This is for
                                                       // not-copy/movable
                                                       // types
          "value must be convertible to specified type in class contract" );
 
        if constexpr( has_json_to_json_data_v<parse_to_t> ) {
          return json_data_contract_trait_t<typename JsonMember::wrapped_type>::
            serialize(
              it,
              json_data_contract<
                typename JsonMember::wrapped_type>::to_json_data( value ),
              value );
        } else if constexpr( is_json_map_alias_v<parse_to_t> ) {
          return json_data_contract_trait_t<parse_to_t>::serialize(
            it, value, value );
        } else if constexpr( std::is_empty_v<parse_to_t> and
                             std::is_default_constructible_v<parse_to_t> and
                             not has_json_data_contract_trait_v<parse_to_t> ) {
          it.write( "{}" );
          return it;
        } else {
          static_assert( is_submember_tagged_variant_v<parse_to_t>,
                         "Could not find appropriate mapping or to_json_data "
                         "member of json_data_contract" );
          return json_data_contract_trait_t<parse_to_t>::serialize( it, value );
        }
      }
 
      template<typename JsonMember, typename WriteableType, typename parse_to_t>
      [[nodiscard]] static constexpr WriteableType
      to_json_string_reflected_class( WriteableType it,
                                      parse_to_t const &value ) {
 
        return JsonMember::serialize( it, value );
      }
 
      template<typename JsonMember, typename WriteableType, typename parse_to_t>
      [[nodiscard]] static constexpr WriteableType
      to_json_string_custom( WriteableType it, parse_to_t const &value ) {
 
        static_assert(
          std::is_convertible_v<parse_to_t, json_result_t<JsonMember>>,
          "value must be convertible to specified type in class contract" );
 
        if constexpr( JsonMember::custom_json_type ==
                      options::JsonCustomTypes::String ) {
          it.put( '"' );
        }
 
        if constexpr( daw::is_callable_r_v<WriteableType,
                                           typename JsonMember::to_converter_t,
                                           WriteableType,
                                           parse_to_t> ) {
          it = typename JsonMember::to_converter_t{ }( it, value );
        } else {
          it = utils::copy_to_iterator(
            it, typename JsonMember::to_converter_t{ }( value ) );
        }
 
        if constexpr( JsonMember::custom_json_type ==
                      options::JsonCustomTypes::String ) {
          it.put( '"' );
        }
        return it;
      }
 
      template<typename JsonMember, typename WriteableType,
               json_options_t SerializationOptions, typename parse_to_t,
               std::size_t... Is>
      DAW_ATTRIB_INLINE constexpr serialization_policy<WriteableType,
                                                       SerializationOptions>
      to_daw_json_string_tuple(
        serialization_policy<WriteableType, SerializationOptions> it,
        parse_to_t const &value, std::index_sequence<Is...> ) {
 
        auto const to_daw_json_string_help = [&]( auto Idx ) {
          using index = daw::remove_cvref_t<decltype( Idx )>;
          using pack_element = tuple_elements_pack<parse_to_t>;
          using T = std::tuple_element_t<index::value,
                                         typename JsonMember::sub_member_list>;
 
          it = to_daw_json_string<T, T::expected_type>(
            it, pack_element::template get<index::value>( value ) );
          if constexpr( index::value + 1 < sizeof...( Is ) ) {
            it.put( ',' );
            it.next_member( );
          }
        };
        (void)to_daw_json_string_help;
 
        daw::empty_t const expander[]{
          ( to_daw_json_string_help( daw::constant_v<Is> ),
            daw::empty_t{ } )...,
          daw::empty_t{ } };
        (void)expander;
 
        return it;
      }
 
      template<typename JsonMember, typename WriteableType,
               json_options_t SerializationOptions, typename parse_to_t>
      [[nodiscard]] static constexpr serialization_policy<WriteableType,
                                                          SerializationOptions>
      to_json_string_tuple(
        serialization_policy<WriteableType, SerializationOptions> it,
        parse_to_t const &value ) {
 
        using tuple_t = json_result_t<JsonMember>;
 
        using element_pack = tuple_elements_pack<typename daw::conditional_t<
          is_tuple_v<tuple_t>,
          daw::traits::identity<tuple_t>,
          json_details::identity_parts<tp_from_struct_binding_result_t,
                                       parse_to_t>>::type>;
 
        static_assert(
          std::is_convertible_v<parse_to_t, tuple_t>,
          "value must be convertible to specified type in class contract" );
 
        it.put( '[' );
        it.add_indent( );
        it.next_member( );
        if constexpr( is_tuple_v<tuple_t> ) {
          it = to_daw_json_string_tuple<JsonMember>(
            it, value, std::make_index_sequence<element_pack::size>{ } );
        } else {
          auto value2 = to_tuple_impl( DAW_FWD( value ) );
 
          using value2_t = tp_from_struct_binding_result_t<parse_to_t>;
          it = to_daw_json_string_tuple<json_base::json_tuple<value2_t>>(
            it, value2, std::make_index_sequence<element_pack::size>{ } );
        }
        it.del_indent( );
        if constexpr( element_pack::size > 0 ) {
          if constexpr( element_pack::size > 0 and
                        it.output_trailing_comma ==
                          options::OutputTrailingComma::Yes ) {
            it.put( ',' );
          }
          it.next_member( );
        }
        it.put( ']' );
        return it;
      }
 
      DAW_JSON_MAKE_REQ_TRAIT(
        is_view_like_v, ( (void)( std::begin( std::declval<T &>( ) ) ),
                          (void)( std::end( std::declval<T &>( ) ) ),
                          (void)( std::declval<typename T::value_type>( ) ) ) );
 
      template<typename JsonMember, typename WriteableType,
               json_options_t SerializationOptions, typename parse_to_t>
      [[nodiscard]] static constexpr serialization_policy<WriteableType,
                                                          SerializationOptions>
      to_json_string_array(
        serialization_policy<WriteableType, SerializationOptions> it,
        parse_to_t const &value ) {
 
        using array_t = json_result_t<JsonMember>;
        if constexpr( is_view_like_v<array_t> ) {
          static_assert(
            std::is_convertible_v<parse_to_t, array_t>,
            "value must be convertible to specified type in class contract" );
        } else {
          static_assert(
            is_pointer_like_v<array_t>,
            "This is a special case for pointer like(T*, unique_ptr<T>, "
            "shared_ptr<T>) arrays.  In the to_json_data it is required to "
            "encode the size of the data with the pointer.  Will take any "
            "Container like type, but std::span like types work too" );
          static_assert(
            is_view_like_v<parse_to_t>,
            "This is a special case for pointer like(T*, unique_ptr<T>, "
            "shared_ptr<T>) arrays.  In the to_json_data it is required to "
            "encode the size of the data with the pointer.  Will take any "
            "Container like type, but std::span like types work too" );
        }
 
        it.put( '[' );
        it.add_indent( );
        auto first = std::begin( value );
        auto last = std::end( value );
        bool const has_elements = first != last;
        while( first != last ) {
          it.next_member( );
          it = to_daw_json_string<typename JsonMember::json_element_t,
                                  JsonMember::json_element_t::expected_type>(
            it, *first );
          ++first;
          if( first != last ) {
            it.put( ',' );
          }
        }
        it.del_indent( );
        if constexpr( it.output_trailing_comma ==
                      options::OutputTrailingComma::Yes ) {
          if( has_elements ) {
            it.put( ',' );
          }
        }
        if( has_elements ) {
          it.next_member( );
        }
        it.put( ']' );
        return it;
      }
 
      template<typename JsonMember, typename WriteableType, typename parse_to_t>
      [[nodiscard]] static constexpr WriteableType
      to_json_string_sized_array( WriteableType it, parse_to_t const &value ) {
        return to_json_string_array<JsonMember>( it, value );
      }
 
      template<typename Key, typename Value>
      static constexpr Key const &
      json_get_key( std::pair<Key, Value> const &kv ) {
        return kv.first;
      }
 
      template<typename Key, typename Value>
      static constexpr Value const &
      json_get_value( std::pair<Key, Value> const &kv ) {
        return kv.second;
      }
 
      template<typename JsonMember, typename WriteableType,
               json_options_t SerializeOptions, typename parse_to_t>
      [[nodiscard]] static constexpr serialization_policy<WriteableType,
                                                          SerializeOptions>
      to_json_string_kv_array(
        serialization_policy<WriteableType, SerializeOptions> it,
        parse_to_t const &value ) {
 
        static_assert(
          std::is_convertible_v<parse_to_t, json_result_t<JsonMember>>,
          "value must be convertible to specified type in class contract" );
        using key_t = typename JsonMember::json_key_t;
        using value_t = typename JsonMember::json_value_t;
        it.put( '[' );
        it.add_indent( );
        auto first = std::begin( value );
        auto last = std::end( value );
        bool const has_elements = first != last;
        while( first != last ) {
          it.next_member( );
          it.put( '{' );
          it.add_indent( );
          it.next_member( );
          // Append Key Name
          it.write( "\"", key_t::name, "\":", it.space );
          // Append Key Value
          it = to_daw_json_string<key_t, key_t::expected_type>(
            it, json_get_key( *first ) );
 
          it.put( ',' );
          // Append Value Name
          it.next_member( );
          it.write( "\"", value_t::name, "\":", it.space );
          // Append Value Value
          it = to_daw_json_string<value_t, value_t::expected_type>(
            it, json_get_value( *first ) );
 
          it.del_indent( );
          if constexpr( it.output_trailing_comma ==
                        options::OutputTrailingComma::Yes ) {
            if( has_elements ) {
              it.put( ',' );
            }
          }
          it.next_member( );
          it.put( '}' );
          ++first;
          if( first != last ) {
            it.put( ',' );
          }
        }
        it.del_indent( );
        if constexpr( it.output_trailing_comma ==
                      options::OutputTrailingComma::Yes ) {
          if( has_elements ) {
            it.put( ',' );
          }
        }
        if( has_elements ) {
          it.next_member( );
        }
        it.put( ']' );
        return it;
      }
 
      template<typename JsonMember, typename WriteableType,
               json_options_t SerializationOptions, typename parse_to_t>
      [[nodiscard]] static constexpr serialization_policy<WriteableType,
                                                          SerializationOptions>
      to_json_string_kv(
        serialization_policy<WriteableType, SerializationOptions> it,
        parse_to_t const &value ) {
 
        it.put( '{' );
        it.add_indent( );
        auto first = std::begin( value );
        auto last = std::end( value );
        bool const has_elements = first != last;
        while( first != last ) {
          auto const &v = *first;
          it.next_member( );
          it = to_daw_json_string<typename JsonMember::json_key_t,
                                  JsonMember::json_key_t::expected_type>(
            it, json_get_key( v ) );
          it.write( ':', it.space );
          it = to_daw_json_string<typename JsonMember::json_element_t,
                                  JsonMember::json_element_t::expected_type>(
            it, json_get_value( v ) );
          ++first;
          if( first != last ) {
            it.put( ',' );
          }
        }
        it.del_indent( );
        if constexpr( it.output_trailing_comma ==
                      options::OutputTrailingComma::Yes ) {
          if( has_elements ) {
            it.put( ',' );
          }
        }
        if( has_elements ) {
          it.next_member( );
        }
        it.put( '}' );
        return it;
      }
 
      template<typename JsonMember, typename WriteableType, typename T>
      [[nodiscard]] static constexpr WriteableType
      to_json_string_submember( WriteableType it, daw::string_view path,
                                T const &value );
 
      template<typename JsonMember, typename WriteableType, typename T>
      [[nodiscard]] static constexpr WriteableType
      to_json_string_submember_array( WriteableType it, daw::string_view path,
                                      T const &value ) {
        auto const index = pop_json_path( path );
        // Only index zero can be reconstructed without inventing preceding
        // array elements. This is a runtime output error because serialization
        // is the operation that requires this stronger path invariant.
        daw_json_ensure( index.found_char == ']' and
                           index.current.size( ) == 1 and
                           index.current.front( ) == '0',
                         ErrorReason::OutputError );
 
        it.put( '[' );
        it.add_indent( );
        it.next_member( );
        if( path.empty( ) ) {
          using member_type = typename JsonMember::member_type;
          it = to_daw_json_string<member_type, member_type::expected_type>(
            it, value );
        } else {
          it = to_json_string_submember<JsonMember>( it, path, value );
        }
        it.del_indent( );
        if constexpr( it.output_trailing_comma ==
                      options::OutputTrailingComma::Yes ) {
          it.put( ',' );
        }
        it.next_member( );
        it.put( ']' );
        return it;
      }
 
      template<typename JsonMember, typename WriteableType, typename T>
      [[nodiscard]] static constexpr WriteableType
      to_json_string_submember( WriteableType it, daw::string_view path,
                                T const &value ) {
        auto const path_item = pop_json_path( path );
        if( path_item.current.empty( ) ) {
          daw_json_ensure( path_item.found_char == '[',
                           ErrorReason::OutputError );
          return to_json_string_submember_array<JsonMember>( it, path, value );
        }
 
        it.put( '{' );
        it.add_indent( );
        it.next_member( );
        it.put( '"' );
        auto name = path_item.current;
        while( not name.empty( ) ) {
          if( name.front( ) == '\\' ) {
            name.remove_prefix( );
            daw_json_ensure( not name.empty( ), ErrorReason::OutputError );
          }
          it.put( name.front( ) );
          name.remove_prefix( );
        }
        it.write( "\":", it.space );
 
        if( path_item.found_char == '[' ) {
          it = to_json_string_submember_array<JsonMember>( it, path, value );
        } else if( path.empty( ) ) {
          using member_type = typename JsonMember::member_type;
          it = to_daw_json_string<member_type, member_type::expected_type>(
            it, value );
        } else {
          it = to_json_string_submember<JsonMember>( it, path, value );
        }
        it.del_indent( );
        if constexpr( it.output_trailing_comma ==
                      options::OutputTrailingComma::Yes ) {
          it.put( ',' );
        }
        it.next_member( );
        it.put( '}' );
        return it;
      }
 
      template<typename JsonMember, JsonParseTypes Tag, typename WriteableType,
               typename parse_to_t>
      [[nodiscard]] DAW_ATTRIB_INLINE static constexpr WriteableType
      to_daw_json_string( WriteableType it, parse_to_t const &value ) {
        if constexpr( Tag == JsonParseTypes::Real ) {
          return to_json_string_real<JsonMember>( it, value );
        } else if constexpr( Tag == JsonParseTypes::Signed ) {
          return to_json_string_signed<JsonMember>( it, value );
        } else if constexpr( Tag == JsonParseTypes::Unsigned ) {
          return to_json_string_unsigned<JsonMember>( it, value );
        } else if constexpr( Tag == JsonParseTypes::Null ) {
          return to_json_string_null<JsonMember>( it, value );
        } else if constexpr( Tag == JsonParseTypes::Bool ) {
          return to_json_string_bool<JsonMember>( it, value );
        } else if constexpr( Tag == JsonParseTypes::StringRaw ) {
          return to_json_string_string_raw<JsonMember>( it, value );
        } else if constexpr( Tag == JsonParseTypes::StringEscaped or
                             Tag == JsonParseTypes::StringInsitu ) {
          return to_json_string_string_escaped<JsonMember>( it, value );
        } else if constexpr( Tag == JsonParseTypes::Date ) {
          return to_json_string_date<JsonMember>( it, value );
        } else if constexpr( Tag == JsonParseTypes::Custom ) {
          return to_json_string_custom<JsonMember>( it, value );
        } else if constexpr( Tag == JsonParseTypes::Class ) {
          return to_json_string_class<JsonMember>( it, value );
        } else if constexpr( Tag == JsonParseTypes::KeyValue ) {
          return to_json_string_kv<JsonMember>( it, value );
        } else if constexpr( Tag == JsonParseTypes::KeyValueArray ) {
          return to_json_string_kv_array<JsonMember>( it, value );
        } else if constexpr( Tag == JsonParseTypes::Array ) {
          return to_json_string_array<JsonMember>( it, value );
        } else if constexpr( Tag == JsonParseTypes::SizedArray ) {
          return to_json_string_sized_array<JsonMember>( it, value );
        } else if constexpr( Tag == JsonParseTypes::Variant ) {
          return to_json_string_variant<JsonMember>( it, value );
        } else if constexpr( Tag == JsonParseTypes::VariantTagged ) {
          return to_json_string_variant_tagged<JsonMember>( it, value );
        } else if constexpr( Tag == JsonParseTypes::VariantIntrusive ) {
          return to_json_string_variant_intrusive<JsonMember>( it, value );
        } else if constexpr( Tag == JsonParseTypes::Tuple ) {
          return to_json_string_tuple<JsonMember>( it, value );
        } else if constexpr( Tag == JsonParseTypes::Submember ) {
          return to_json_string_submember<JsonMember>(
            it, JsonMember::json_path, value );
#if defined( DAW_JSON_HAS_REFLECTION )
        } else if constexpr( Tag == JsonParseTypes::ReflectedClass ) {
          return to_json_string_reflected_class<JsonMember>( it, value );
#endif
        } else /*if constexpr( Tag == JsonParseTypes::Unknown )*/ {
          static_assert( Tag == JsonParseTypes::Unknown,
                         "Unexpected JsonParseType" );
          return to_json_string_unknown<JsonMember>( it, value );
        }
      }
 
      template<typename JsonMember, typename WriteableType, typename T>
      [[nodiscard]] static constexpr WriteableType
      member_to_string( WriteableType it, T const &value ) {
        return to_daw_json_string<JsonMember, JsonMember::expected_type>(
          std::move( it ), value );
      }
 
      template<typename>
      struct missing_required_mapping_for {};
 
      // This is only ever called in a constant expression. But will not
      // compile if exceptions are disabled and it tries to throw
      template<typename Name>
      [[noreturn]] DAW_ATTRIB_NOINLINE void missing_required_mapping_error( ) {
#if defined( DAW_USE_EXCEPTIONS )
        throw missing_required_mapping_for<Name>{ };
#else
        std::terminate( );
#endif
      }
 
      template<typename, typename...>
      struct find_names_in_pack;
 
      template<typename Needle, typename... Haystack>
      struct find_names_in_pack<Needle, daw::fwd_pack<Haystack...>> {
      private:
        static constexpr daw::simple_array<daw::string_view,
                                           sizeof...( Haystack )>
          names = { Haystack::name... };
        static_assert( ( ( Haystack::name == Needle::name ) or ... ),
                       "Name must exist" );
 
      public:
        static DAW_CONSTEVAL std::size_t find_position( ) {
          std::size_t n = 0;
          for( ; n < sizeof...( Haystack ); ++n ) {
            if( Needle::name == names[n] ) {
              return n;
            }
          }
          if( n >= sizeof...( Haystack ) ) {
            missing_required_mapping_error<Needle>( );
          }
          DAW_UNREACHABLE( );
        }
 
        static constexpr std::size_t value = find_position( );
      };
 
      template<typename Needle, typename... Haystack>
      inline static constexpr std::size_t find_names_in_pack_v =
        find_names_in_pack<Needle, Haystack...>::value;
 
      template<std::size_t pos, typename JsonMember, typename NamePack,
               typename WriteableType, json_options_t SerializationOptions,
               typename TpArgs, typename Value, typename VisitedMembers>
      static constexpr void dependent_member_to_json_str(
        bool &is_first,
        serialization_policy<WriteableType, SerializationOptions> it,
        TpArgs const &args, Value const &v, VisitedMembers &visited_members ) {
        if constexpr( not has_dependent_member_v<JsonMember> ) {
          (void)is_first;
          (void)it;
          (void)args;
          (void)v;
          (void)visited_members;
          return;
        } else {
          using base_member_t = typename daw::conditional_t<
            is_json_nullable_v<JsonMember>,
            ident_trait<json_nullable_member_type_t, JsonMember>,
            daw::traits::identity<JsonMember>>::type;
 
          using dependent_member = dependent_member_t<base_member_t>;
 
          using daw::get;
          using std::get;
          static_assert( is_a_json_type_v<JsonMember>,
                         "Unsupported data type" );
          if constexpr( is_json_nullable_v<JsonMember> ) {
            if constexpr( JsonMember::nullable == JsonNullable::Nullable ) {
              // We have no requirement to output this member when it's null
              if( not get<pos>( args ) ) {
                return;
              }
            }
          }
          if( daw::algorithm::contains( std::data( visited_members ),
                                        daw::data_end( visited_members ),
                                        dependent_member::name ) ) {
            // Already outputted this member
            return;
          }
          visited_members.push_back( dependent_member::name );
          if( not is_first ) {
            it.put( ',' );
          }
          it.next_member( );
          is_first = false;
          it.write( '"', dependent_member::name, "\":", it.space );
 
          if constexpr( has_switcher_v<base_member_t> ) {
            it = member_to_string<dependent_member>(
              it, typename base_member_t::switcher{ }( v ) );
          } else {
            using idx =
              daw::constant<find_names_in_pack_v<dependent_member, NamePack>>;
            it =
              member_to_string<dependent_member>( it, get<idx::value>( args ) );
          }
          (void)it;
        }
      }
 
      template<std::size_t pos, typename JsonMember, typename WriteableType,
               json_options_t SerializationOptions, typename Tuple,
               typename Value, typename Visited>
      static constexpr void to_json_str(
        bool &is_first,
        serialization_policy<WriteableType, SerializationOptions> &it,
        Tuple const &tp, Value const &, Visited &visited_members ) {
        DAW_CPP23_STATIC_LOCAL constexpr auto json_member_name =
          daw::string_view( std::data( JsonMember::name ),
                            std::size( JsonMember::name ) );
        if( daw::algorithm::contains( std::data( visited_members ),
                                      daw::data_end( visited_members ),
                                      json_member_name ) ) {
          return;
        }
        visited_members.push_back( json_member_name );
        static_assert( is_a_json_type_v<JsonMember>, "Unsupported data type" );
        if constexpr( is_json_nullable_v<JsonMember> ) {
          if constexpr( JsonMember::nullable == JsonNullable::Nullable ) {
            if( not concepts::nullable_value_has_value( get<pos>( tp ) ) ) {
              return;
            }
            if constexpr( has_null_checker_v<JsonMember> ) {
              if( typename JsonMember::is_null_checker{ }( get<pos>( tp ) ) ) {
                return;
              }
            }
          }
        }
        if( not is_first ) {
          it.put( ',' );
        }
        it.next_member( );
        is_first = false;
        it.write( '"', JsonMember::name, "\":", it.space );
 
        it = member_to_string<JsonMember>( std::move( it ), get<pos>( tp ) );
      }
 
      template<std::size_t TupleIdx, typename JsonMember,
               typename WriteableType, json_options_t SerializerOptions,
               template<class...> class Tuple, typename... Args>
      static constexpr void to_json_ordered_str(
        std::size_t &array_idx, std::size_t array_size,
        serialization_policy<WriteableType, SerializerOptions> &it,
        Tuple<Args...> const &tp ) {
 
        using json_member_type = ordered_member_subtype_t<JsonMember>;
        static_assert( is_a_json_type_v<json_member_type>,
                       "Unsupported data type" );
        // json_tagged_variant like members cannot work as we have no member
        // names to work with
        static_assert(
          not is_a_json_tagged_variant_v<json_member_type>,
          "JSON tagged variant types are not supported when inside an array "
          "as an ordered structure" );
 
        if constexpr( is_an_ordered_member_v<JsonMember> ) {
          for( ; array_idx < JsonMember::member_index; ++array_idx ) {
            it.next_member( );
            it.write( "null," );
            it.next_member( );
          }
        }
        it = member_to_string<json_member_type>( it, get<TupleIdx>( tp ) );
        ++array_idx;
        if( array_idx < array_size ) {
          it.put( ',' );
          it.next_member( );
        }
      }
 
 
      template<options::FPOutputFormat fp_output_format, unsigned Precision,
               typename Real, typename WriteableType>
      constexpr WriteableType to_chars( Real const &value,
                                        WriteableType out_it ) {
        daw::jkj::dragonbox::unsigned_fp_t<Real> dec =
          daw::jkj::dragonbox::to_decimal(
            value, daw::jkj::dragonbox::policy::sign::ignore );
        auto const original_digits =
          daw::jkj::dragonbox::to_chars_detail::decimal_length(
            dec.significand );
        static_assert(
          daw::max_digits10<Real> < daw::digits10<std::uintmax_t>,
          "The integer pow10 table must cover every Dragonbox significand "
          "digit" );
        unsigned decimal_places = 0;
        unsigned scientific_places = 0;
        // Round a decimal significand to a requested number of significant
        // digits.  Dragonbox gives us the exact shortest decimal, so doing
        // this here avoids a second (and potentially lossy) conversion.
        auto round_significand = [&]( unsigned digits ) constexpr {
          if( digits == 0 ) {
            digits = 1;
          }
          if( original_digits <= digits ) {
            return;
          }
          auto const remove = original_digits - digits;
          using carrier_t = decltype( dec.significand );
          auto const divisor =
            static_cast<carrier_t>( daw::cxmath::pow10( remove ) );
          auto quotient = dec.significand / divisor;
          auto const remainder = dec.significand % divisor;
          auto const halfway = divisor / 2;
          if( remainder > halfway or
              ( remainder == halfway and ( quotient & 1U ) != 0U ) ) {
            ++quotient;
          }
          dec.significand = quotient;
          dec.exponent += static_cast<int>( remove );
          if( daw::jkj::dragonbox::to_chars_detail::decimal_length(
                dec.significand ) > digits ) {
            // Rounding 9.99 to two digits, for example, produces 10.
            dec.significand /= 10;
            ++dec.exponent;
          }
        };
        if constexpr( Precision != daw::max_value<unsigned> ) {
          if constexpr( fp_output_format == options::FPOutputFormat::Auto ) {
            // trim sig digits to at most precision and adjust exponent as
            // needed auto chosen decimal/scientific
            round_significand( Precision );
          } else if constexpr( fp_output_format ==
                               options::FPOutputFormat::Decimal ) {
            // fixed width/padded to Precisioin in Decimal notation
            decimal_places = Precision;
            if( dec.exponent < -static_cast<int>( Precision ) ) {
              using carrier_t = decltype( dec.significand );
              auto const remove = static_cast<unsigned>(
                -static_cast<long long>( dec.exponent ) - Precision );
              if( remove > original_digits ) {
                // The discarded power of ten is larger than the entire
                // significand, so the value is strictly below half of the
                // least retained decimal place.  It rounds to zero without
                // constructing a power of ten that cannot fit in carrier_t.
                dec.significand = 0;
              } else {
                auto const divisor =
                  static_cast<carrier_t>( daw::cxmath::pow10( remove ) );
                auto quotient = dec.significand / divisor;
                auto const remainder = dec.significand % divisor;
                auto const halfway = divisor / 2;
                if( remainder > halfway or
                    ( remainder == halfway and ( quotient & 1U ) != 0U ) ) {
                  ++quotient;
                }
                dec.significand = quotient;
              }
              dec.exponent = -static_cast<int>( Precision );
            }
          } else if constexpr( fp_output_format ==
                               options::FPOutputFormat::Scientific ) {
            // fixed width/padded to Precisioin in Scientific
            scientific_places = Precision;
            round_significand( Precision + 1 );
            // Scientific output requires exactly Precision digits after
            // the point.  Add insignificant zeroes to the significand.
            unsigned const wanted = Precision + 1;
            unsigned current =
              daw::jkj::dragonbox::to_chars_detail::decimal_length(
                dec.significand );
            while( current < wanted and current < 19 ) {
              dec.significand *= 10;
              --dec.exponent;
              ++current;
            }
          } else if constexpr( fp_output_format ==
                               options::FPOutputFormat::Minimum ) {
            // trim to at most Precision significant digits.  Use smallest rep
            round_significand( Precision );
          }
        }
        auto const digit_values =
          daw::jkj::dragonbox::to_chars_detail::decimal_length(
            dec.significand );
 
        auto whole_dig =
          static_cast<std::int32_t>( digit_values ) + dec.exponent;
 
        auto const br = [&] {
          if constexpr( std::is_same_v<Real, float> ) {
            return daw::jkj::dragonbox::ieee754_bits( value );
          } else {
            return daw::jkj::dragonbox::ieee754_bits(
              static_cast<double>( value ) );
          }
        }( );
        if( dec.significand == 0 ) {
          if( fp_output_format == options::FPOutputFormat::Decimal ) {
            out_it.put( '0' );
            if constexpr( Precision != daw::max_value<unsigned> ) {
              if( decimal_places != 0 ) {
                out_it.put( '.' );
                for( unsigned n = 0; n < decimal_places; ++n ) {
                  out_it.put( '0' );
                }
              }
            } else {
              out_it.write( ".0" );
            }
          } else {
            out_it.put( '0' );
          }
          return out_it;
        }
        if( br.is_negative( ) ) {
          out_it.put( '-' );
        }
        if constexpr( fp_output_format ==
                      options::FPOutputFormat::Scientific ) {
          char buff[50]{ };
          char *ptr = buff;
          ptr = daw::jkj::dragonbox::to_chars_detail::to_chars(
            dec, ptr, digit_values );
          if( scientific_places == 0 ) {
            out_it.copy_buffer( buff, ptr );
          } else {
            char const *epos = buff;
            while( epos != ptr and *epos != 'e' ) {
              ++epos;
            }
            char const *dot = buff;
            while( dot != epos and *dot != '.' ) {
              ++dot;
            }
            if( dot == epos ) {
              out_it.copy_buffer( buff, epos );
              out_it.put( '.' );
            } else {
              out_it.copy_buffer( buff, dot + 1 );
              out_it.copy_buffer( dot + 1, epos );
            }
            unsigned count =
              dot == epos ? 0U : static_cast<unsigned>( epos - dot - 1 );
            while( count < scientific_places ) {
              out_it.put( '0' );
              ++count;
            }
            out_it.copy_buffer( epos, ptr );
          }
          return out_it;
        } else if constexpr( fp_output_format ==
                             options::FPOutputFormat::Auto ) {
          if( ( whole_dig < -4 ) | ( whole_dig > 6 ) ) {
            char buff[50]{ };
            char *ptr = buff;
            ptr = daw::jkj::dragonbox::to_chars_detail::to_chars(
              dec, ptr, digit_values );
            out_it.copy_buffer( buff, ptr );
            return out_it;
          }
        }
        if( dec.exponent < 0 ) {
          if( whole_dig < 0 ) {
            out_it.write( "0." );
            do {
              out_it.put( '0' );
              ++whole_dig;
            } while( whole_dig < 0 );
            out_it = utils::integer_to_string( out_it, dec.significand );
            if constexpr( Precision != daw::max_value<unsigned> ) {
              for( auto n = static_cast<unsigned>( -dec.exponent );
                   n < decimal_places;
                   ++n ) {
                out_it.put( '0' );
              }
            }
            return out_it;
          }
          // TODO allow for decimal output for all
          auto const p1pow =
            daw::cxmath::pow10( static_cast<std::size_t>( -dec.exponent ) );
          auto const p1val = dec.significand / p1pow;
          out_it = utils::integer_to_string( out_it, p1val );
          if( p1pow == 1 ) {
            return out_it;
          }
          out_it.put( '.' );
          auto const p2val = dec.significand - ( p1val * p1pow );
          // ensure we account for leading zeros
          {
            auto const l10_p1val = daw::cxmath::count_digits( p1val );
            auto const l10_p2val = daw::cxmath::count_digits( p2val );
            auto const extra_zeros =
              static_cast<int>( digit_values ) - ( l10_p2val + l10_p1val );
            for( int n = 0; n < extra_zeros; ++n ) {
              out_it.put( '0' );
            }
          }
          out_it = utils::integer_to_string( out_it, p2val );
          if constexpr( Precision != daw::max_value<unsigned> ) {
            for( auto n = static_cast<unsigned>( -dec.exponent );
                 n < decimal_places;
                 ++n ) {
              out_it.put( '0' );
            }
          }
          return out_it;
        }
        out_it = utils::integer_to_string( out_it, dec.significand );
 
        while( dec.exponent > 0 ) {
          out_it.put( '0' );
          --dec.exponent;
        }
        if( fp_output_format == options::FPOutputFormat::Decimal ) {
          if constexpr( Precision == daw::max_value<unsigned> ) {
            out_it.put( '.' );
            out_it.put( '0' );
          } else {
            if( decimal_places != 0 ) {
              out_it.put( '.' );
              for( unsigned n = 0; n < decimal_places; ++n ) {
                out_it.put( '0' );
              }
            }
          }
        }
        return out_it;
      }
    } // namespace json_details
  } // namespace DAW_JSON_VER
} // namespace daw::json