daw_writable_output_details.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/impl/daw_json_assert.h"
 
#include <daw/daw_algorithm.h>
#include <daw/daw_character_traits.h>
#include <daw/daw_string_view.h>
 
#include <cstddef>
#include <cstdio>
#include <type_traits>
#include <utility>
 
namespace daw::json {
  inline namespace DAW_JSON_VER {
    namespace concepts::writeable_output_details {
      template<typename T>
      constexpr T *copy_to_buffer( T *buff, daw::string_view source ) {
        if( DAW_IS_CONSTANT_EVALUATED_COMPAT( ) ) {
          daw::algorithm::transform_n( source.data( ),
                                       buff,
                                       source.size( ),
                                       []( auto c )
                                         DAW_JSON_CPP23_STATIC_CALL_OP {
                                           return static_cast<T>( c );
                                         } );
        } else {
          memcpy( buff, source.data( ), source.size( ) );
        }
        return buff + source.size( );
      }
 
      template<typename T, typename = void>
      inline constexpr bool has_capacity_reserve_v = false;
 
      template<typename T>
      inline constexpr bool has_capacity_reserve_v<
        T, std::void_t<decltype( std::declval<T &>( ).capacity( ) ),
                       decltype( std::declval<T &>( ).reserve(
                         std::size_t{ } ) )>> = true;
 
      template<typename T>
      DAW_CPP20_CONCEPT is_byte_type_v =
        std::is_same_v<T, std::byte> or std::is_same_v<T, unsigned char>;
 
      template<typename T>
      DAW_CPP20_CONCEPT is_char_sized_character_v =
        std::is_same_v<T, char>
#if defined( __cpp_lib_char8_t )
#if __cpp_lib_char8_t >= 201907L
        or std::is_same_v<T, char8_t>
#endif
#endif
        ;
 
      template<typename T, typename CharT>
      using span_like_range_test =
        decltype( (void)( std::declval<T &>( ).subspan( 1 ) ),
                  (void)( std::declval<std::size_t &>( ) =
                            std::declval<T &>( ).size( ) ),
                  (void)( std::declval<bool &>( ) =
                            std::declval<T &>( ).empty( ) ),
                  (void)( *std::declval<T &>( ).data( ) =
                            std::declval<CharT>( ) ) );
      // std::span has only subspan; daw::span and string views also have
      // remove_prefix
      template<typename T>
      using remove_prefix_test =
        decltype( std::declval<T &>( ).remove_prefix( std::size_t{ 1 } ) );
 
      template<typename T>
      DAW_CPP20_CONCEPT has_remove_prefix_v =
        daw::is_detected_v<remove_prefix_test, T>;
 
      template<typename T, typename CharT>
      DAW_CPP20_CONCEPT is_span_like_range_v =
        daw::is_detected_v<span_like_range_test, T, CharT> and
        ( writeable_output_details::is_char_sized_character_v<CharT> or
          writeable_output_details::is_byte_type_v<CharT> );
 
      template<typename T, typename CharT>
      using resizable_contiguous_range_test =
        decltype( (void)( std::declval<T &>( ).resize( std::size_t{ 0 } ) ),
                  (void)( std::declval<T &>( ).size( ) ),
                  (void)( *std::declval<T &>( ).data( ) ),
                  (void)( *std::declval<T &>( ).data( ) =
                            std::declval<CharT>( ) ),
                  (void)( std::declval<T &>( ).push_back(
                    std::declval<CharT>( ) ) ),
                  (void)( static_cast<CharT>( 'a' ) ) );
 
      template<typename Container, typename CharT>
      DAW_CPP20_CONCEPT is_resizable_contiguous_range_v =
        daw::is_detected_v<resizable_contiguous_range_test, Container, CharT>;
 
      template<typename Container, typename CharT>
      DAW_CPP20_CONCEPT is_string_like_writable_output_v =
        ( writeable_output_details::is_char_sized_character_v<CharT> or
          writeable_output_details::is_byte_type_v<CharT> ) and
        writeable_output_details::is_resizable_contiguous_range_v<Container,
                                                                  CharT>;
 
      template<typename T>
      using is_writable_output_iterator_test =
        decltype( *std::declval<T &>( ) = 'c', ++std::declval<T &>( ) );
 
      template<typename T>
      DAW_CPP20_CONCEPT is_writable_output_iterator_v =
        not std::is_pointer_v<T> and
        daw::is_detected_v<is_writable_output_iterator_test, T>;
    } // namespace concepts::writeable_output_details
  } // namespace DAW_JSON_VER
} // namespace daw::json