daw_json_name.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_req_helper.h"
 
#include <daw/daw_consteval.h>
#include <daw/daw_cpp20_concept.h>
#include <daw/daw_cpp_feature_check.h>
#include <daw/daw_likely.h>
#include <daw/daw_string_view.h>
 
#include <cstddef>
#include <string_view>
#include <utility>
#if defined( DAW_JSON_HAS_REFLECTION )
#include <meta>
#endif
 
namespace daw::json {
  inline namespace DAW_JSON_VER {
 
#if defined( DAW_JSON_CNTTP_JSON_NAME )
    // C++ 20 Non-Type Class Template Arguments
 
#if defined( DAW_JSON_HAS_REFLECTION )
    struct json_name {
      char const *m_data{ };
      std::size_t m_size{ };
 
      template<std::size_t N>
      consteval json_name( char const ( &ptr )[N] ) noexcept
        : json_name( daw::string_view( ptr, N - 1 ) ) {}
 
      consteval json_name( daw::string_view sv ) noexcept
        : m_data( std::define_static_string( sv ) )
        , m_size( sv.size( ) ) {}
 
      [[nodiscard]] DAW_ATTRIB_INLINE constexpr
      operator daw::string_view( ) const noexcept {
        return { m_data, m_size };
      }
 
      // Needed for copy_to_iterator
      [[nodiscard]] DAW_ATTRIB_RET_NONNULL
        DAW_ATTRIB_INLINE constexpr char const *
        begin( ) const noexcept {
        return m_data;
      }
 
      // Needed for copy_to_iterator
      [[nodiscard]] DAW_ATTRIB_RET_NONNULL
        DAW_ATTRIB_INLINE constexpr char const *
        end( ) const noexcept {
        return m_data + m_size;
      }
 
      [[nodiscard]] constexpr std::size_t size( ) const {
        return m_size;
      }
 
      [[nodiscard]] constexpr bool empty( ) const {
        return m_size == 0;
      }
 
      [[nodiscard]] constexpr bool
      operator==( json_name const &rhs ) const noexcept {
        return daw::string_view( m_data, m_size ) ==
               daw::string_view( rhs.m_data, rhs.m_size );
      }
 
      [[nodiscard]] DAW_ATTRIB_INLINE constexpr bool
      operator==( daw::string_view rhs ) const noexcept {
        return daw::string_view( m_data, m_size ) == rhs;
      }
 
      [[nodiscard]] DAW_ATTRIB_INLINE constexpr
      operator std::string_view( ) const noexcept {
        return std::string_view( m_data, m_size );
      }
    };
#else
    template<std::size_t N>
    struct json_name {
      static_assert( N > 0 );
      char const m_data[N]{ };
 
      template<std::size_t... Is>
      DAW_ATTRIB_INLINE DAW_CONSTEVAL json_name(
        daw::not_null<char const *> ptr, std::index_sequence<Is...> ) noexcept
        : m_data{ ptr[Is]... } {}
 
      DAW_ATTRIB_INLINE DAW_CONSTEVAL
      json_name( char const ( &ptr )[N] ) noexcept
        : json_name( ptr, std::make_index_sequence<N>{ } ) {}
 
      [[nodiscard]] DAW_ATTRIB_INLINE constexpr
      operator daw::string_view( ) const noexcept {
        return { m_data, N - 1 };
      }
 
      // Needed for copy_to_iterator
      [[nodiscard]] DAW_ATTRIB_RET_NONNULL
        DAW_ATTRIB_INLINE constexpr char const *
        begin( ) const noexcept {
        return m_data;
      }
 
      // Needed for copy_to_iterator
      [[nodiscard]] DAW_ATTRIB_RET_NONNULL
        DAW_ATTRIB_INLINE constexpr char const *
        end( ) const noexcept {
        return m_data + static_cast<ptrdiff_t>( size( ) );
      }
 
      [[nodiscard]] static DAW_CONSTEVAL std::size_t size( ) {
        return N - 1;
      }
 
      [[nodiscard]] static DAW_CONSTEVAL bool empty( ) {
        return size( ) == 0;
      }
 
      template<std::size_t M>
      [[nodiscard]] constexpr bool
      operator==( json_name<M> const &rhs ) const noexcept {
        if( N != M ) {
          return false;
        }
        for( std::size_t n = 0; n < N; ++n ) {
          if( m_data[n] != rhs.m_data[n] ) {
            return false;
          }
        }
        return true;
      }
 
      [[nodiscard]] DAW_ATTRIB_INLINE constexpr bool
      operator==( daw::string_view rhs ) const noexcept {
        return daw::string_view( m_data, N - 1 ) == rhs;
      }
 
      [[nodiscard]] DAW_ATTRIB_INLINE constexpr bool
      operator==( std::string_view rhs ) const noexcept {
        return std::string_view( m_data, N - 1 ) == rhs;
      }
 
      [[nodiscard]] DAW_ATTRIB_INLINE constexpr
      operator std::string_view( ) const noexcept {
        return std::string_view( m_data, N - 1 );
      }
    };
    template<typename... Chars>
    json_name( Chars... ) -> json_name<sizeof...( Chars )>;
 
    template<std::size_t N>
    json_name( char const ( & )[N] ) -> json_name<N>;
#endif
#define JSONNAMETYPE ::daw::json::json_name
    inline constexpr JSONNAMETYPE default_key_name{ "key" };
    inline constexpr JSONNAMETYPE default_value_name{ "value" };
 
#else
#define JSONNAMETYPE char const *
    inline constexpr char const default_key_name[] = "key";
    inline constexpr char const default_value_name[] = "value";
#endif
    namespace json_details {
      DAW_JSON_MAKE_REQ_TRAIT( has_name_v, T::name );
 
      template<typename... Ts>
      DAW_CPP20_CONCEPT all_have_name_v = ( has_name_v<Ts> and ... );
 
      template<typename T>
      DAW_CPP20_CONCEPT is_no_name_v = not has_name_v<T>;
 
      template<typename... Ts>
      DAW_CPP20_CONCEPT are_no_name_v = ( is_no_name_v<Ts> and ... );
    } // namespace json_details
  } // namespace DAW_JSON_VER
} // namespace daw::json