daw_to_json.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/concepts/daw_writable_output.h"
#include "daw/json/daw_to_json_fwd.h"
#include "daw/json/impl/daw_json_container_appender.h"
#include "daw/json/impl/daw_json_link_types_fwd.h"
#include "daw/json/impl/to_daw_json_string.h"
 
#include <daw/daw_enable_requires.h>
#include <daw/daw_span.h>
#include <daw/daw_string_view.h>
#include <daw/daw_traits.h>
 
#include <iterator>
#include <optional>
#include <string>
#include <type_traits>
#include <utility>
 
namespace daw::json {
  inline namespace DAW_JSON_VER {
    namespace json_details {
      template<typename output_t, auto... PolicyFlags, typename WritableType>
      DAW_ATTRIB_INLINE constexpr auto apply_policy_flags( WritableType &&it ) {
        if constexpr( is_serialization_policy_v<
                        daw::remove_cvref_t<WritableType>> ) {
          if constexpr( sizeof...( PolicyFlags ) == 0 ) {
            return it;
          } else {
            return serialization_policy<typename output_t::iterator_type,
                                        json_details::serialization::set_bits(
                                          output_t::policy_flags( ),
                                          PolicyFlags... )>( it.get( ) );
          }
        } else {
          return serialization_policy<
            daw::remove_cvref_t<WritableType>,
            options::output_flags_t<PolicyFlags...>::value>( it );
        }
      }
    } // namespace json_details
 
    template<
      typename JsonClass, typename Value, typename WritableType,
      auto... PolicyFlags DAW_ENABLEIF2( concepts::is_writable_output_type_v<
                                         daw::remove_cvref_t<WritableType>> )>
    DAW_REQUIRES(
      concepts::is_writable_output_type_v<daw::remove_cvref_t<WritableType>> )
    constexpr daw::rvalue_to_value_t<WritableType> to_json(
      Value const &value, WritableType &&it,
      options::output_flags_t<PolicyFlags...> flags ) {
      if constexpr( json_details::is_char_pointer_v<Value> ) {
        // A nul terminated string, nullptr is null.  An explicit JsonClass
        // is given the string_view
        if( value == nullptr ) {
          return to_json<use_default>(
            std::optional<daw::string_view>( ), DAW_FWD( it ), flags );
        }
        return to_json<JsonClass>(
          daw::string_view( value ), DAW_FWD( it ), flags );
      } else if constexpr( json_details::is_char_array_v<Value> ) {
        // Exclude the trailing nul.  An explicit JsonClass is given the
        // string_view
        return to_json<JsonClass>(
          daw::string_view( value, std::extent_v<Value> - 1U ),
          DAW_FWD( it ),
          flags );
      } else {
        using json_class_t =
          json_details::json_serialize_deduced_type<JsonClass, Value>;
 
        using output_t = daw::rvalue_to_value_t<WritableType>;
        if constexpr( std::is_pointer_v<daw::remove_cvref_t<WritableType>> ) {
          daw_json_ensure( it != nullptr, ErrorReason::NullOutputIterator );
        }
        auto out_it =
          json_details::apply_policy_flags<output_t, PolicyFlags...>( it );
 
        out_it = json_details::member_to_string<json_class_t>( out_it, value );
        return out_it.get( );
      }
    }
 
    template<typename JsonClass, typename Value, auto... PolicyFlags>
    DAW_CPP20_CX_ALLOC std::string
    to_json( Value const &value,
             options::output_flags_t<PolicyFlags...> flgs ) {
      auto out = string_writer( );
      (void)to_json<JsonClass>( value, out, flgs );
      return std::move( out ).finish( );
    }
 
    namespace json_details {
      template<auto... PolicyFlags, typename WritableType>
      constexpr auto make_output_iterator( WritableType &&it ) {
        using output_t = daw::rvalue_to_value_t<WritableType>;
 
        if constexpr( std::is_pointer_v<daw::remove_cvref_t<output_t>> ) {
          daw_json_ensure( it != nullptr, ErrorReason::InvalidNull );
        }
        if constexpr( is_serialization_policy_v<
                        daw::remove_cvref_t<WritableType>> ) {
          if constexpr( sizeof...( PolicyFlags ) == 0 ) {
            return it;
          } else {
            return serialization_policy<typename output_t::iterator_type,
                                        json_details::serialization::set_bits(
                                          output_t::policy_flags( ),
                                          PolicyFlags... )>( it.get( ) );
          }
        } else {
          return serialization_policy<
            daw::remove_cvref_t<WritableType>,
            options::output_flags_t<PolicyFlags...>::value>( it );
        }
      }
    } // namespace json_details
 
    template<
      typename JsonElement, typename Container, typename WritableType,
      auto... PolicyFlags DAW_ENABLEIF2( concepts::is_writable_output_type_v<
                                         daw::remove_cvref_t<WritableType>> )>
    DAW_REQUIRES(
      concepts::is_writable_output_type_v<daw::remove_cvref_t<WritableType>> )
    constexpr daw::rvalue_to_value_t<WritableType> to_json_array(
      Container const &c, WritableType &&it,
      options::output_flags_t<PolicyFlags...> flags ) {
      if constexpr( json_details::is_char_array_v<Container> ) {
        // Exclude the trailing nul, same as to_json and json_writer
        return to_json_array<JsonElement>(
          daw::string_view( c, std::extent_v<Container> - 1U ),
          DAW_FWD( it ),
          flags );
      } else if constexpr( std::is_array_v<Container> ) {
        return to_json_array<JsonElement>(
          daw::span<std::remove_extent_t<Container> const>(
            c, std::extent_v<Container> ),
          DAW_FWD( it ),
          flags );
      } else if constexpr( std::is_pointer_v<Container> ) {
        static_assert( daw::deduced_false_v<Container>,
                       "Pointers have no length, pass a span or container" );
      } else {
        static_assert(
          daw::traits::is_container_like_v<daw::remove_cvref_t<Container>>,
          "Supplied container must support begin( )/end( )" );
 
        auto out_it =
          json_details::make_output_iterator<PolicyFlags...>( DAW_FWD( it ) );
        json_details::reserve_array_output<
          json_details::json_serialize_deduced_type<
            JsonElement, daw::remove_cvref_t<decltype( *std::begin( c ) )>>>(
          out_it, c );
        out_it.put( '[' );
        out_it.add_indent( );
        // Not const & as some types(vector<bool>::const_reference are not ref
        // types
        auto first = std::begin( c );
        auto last = std::end( c );
        bool const has_elements = first != last;
        while( first != last ) {
          (void)[&out_it]( auto &&v ) {
            using v_type = DAW_TYPEOF( v );
            using JsonMember =
              json_details::json_serialize_deduced_type<JsonElement, v_type>;
 
            static_assert(
              not std::is_same_v<
                JsonMember,
                missing_json_data_contract_for_or_unknown_type<JsonElement>>,
              "Unable to detect unnamed mapping" );
            // static_assert( not std::is_same_v<JsonElement, JsonMember> );
            out_it.next_member( );
 
            out_it = json_details::member_to_string<JsonMember>( out_it, v );
          }
          ( *first );
          ++first;
          if( first != last ) {
            out_it.put( ',' );
          }
        }
        // The last character will be a ',' prior to this
        out_it.del_indent( );
        if( has_elements ) {
          out_it.output_newline( );
        }
        out_it.put( ']' );
        return out_it.get( );
      }
    }
 
    template<typename JsonElement, typename Container, auto... PolicyFlags>
    DAW_CPP20_CX_ALLOC std::string
    to_json_array( Container const &c,
                   options::output_flags_t<PolicyFlags...> flgs ) {
      static_assert( not std::is_same_v<std::string, JsonElement> );
      auto out = string_writer( );
      (void)to_json_array<JsonElement>( c, out, flgs );
      return std::move( out ).finish( );
    }
  } // namespace DAW_JSON_VER
} // namespace daw::json