couchbase 3.0.3-universal-darwin-20

data/ext/third_party/json/include/tao/json/contrib/internal/array_traits.hpp

@@ -0,0 +1,92 @@
+// Copyright (c) 2018-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/json/
+
+#ifndef TAO_JSON_CONTRIB_INTERNAL_ARRAY_TRAITS_HPP
+#define TAO_JSON_CONTRIB_INTERNAL_ARRAY_TRAITS_HPP
+
+#include <algorithm>
+
+#include "../../forward.hpp"
+#include "../../type.hpp"
+
+#include "../../events/produce.hpp"
+
+namespace tao::json::internal
+{
+   template< typename T >
+   struct array_multi_traits
+   {
+      template< template< typename... > class Traits >
+      [[nodiscard]] static bool is_nothing( const T& o )
+      {
+         return o.empty();
+      }
+
+      template< template< typename... > class Traits >
+      static void assign( basic_value< Traits >& v, const T& o ) = delete;
+
+      template< template< typename... > class Traits, typename Consumer >
+      static void produce( Consumer& c, const T& o )
+      {
+         c.begin_array( o.size() );
+         for( const auto& i : o ) {
+            json::events::produce< Traits >( c, i );
+            c.element();
+         }
+         c.end_array( o.size() );
+      }
+
+      template< template< typename... > class Traits >
+      [[nodiscard]] static bool equal( const basic_value< Traits >& lhs, const T& rhs ) noexcept
+      {
+         const auto& p = lhs.skip_value_ptr();
+         if( !p.is_array() ) {
+            return false;
+         }
+         const auto& a = p.get_array();
+         return ( a.size() == rhs.size() ) && std::equal( rhs.begin(), rhs.end(), a.begin() );
+      }
+
+      template< template< typename... > class Traits >
+      [[nodiscard]] static bool less_than( const basic_value< Traits >& lhs, const T& rhs ) noexcept
+      {
+         const auto& p = lhs.skip_value_ptr();
+         const auto t = p.type();
+         if( t != type::ARRAY ) {
+            return t < type::ARRAY;
+         }
+         const auto& a = p.get_array();
+         return std::lexicographical_compare( a.begin(), a.end(), rhs.begin(), rhs.end() );
+      }
+
+      template< template< typename... > class Traits >
+      [[nodiscard]] static bool greater_than( const basic_value< Traits >& lhs, const T& rhs ) noexcept
+      {
+         const auto& p = lhs.skip_value_ptr();
+         const auto t = p.type();
+         if( t != type::ARRAY ) {
+            return t > type::ARRAY;
+         }
+         const auto& a = p.get_array();
+         return std::lexicographical_compare( rhs.begin(), rhs.end(), a.begin(), a.end() );
+      }
+   };
+
+   template< typename T >
+   struct array_traits
+      : array_multi_traits< T >
+   {
+      template< template< typename... > class Traits >
+      static void assign( basic_value< Traits >& v, const T& o )
+      {
+         v.emplace_array();
+         v.get_array().reserve( o.size() );
+         for( const auto& e : o ) {
+            v.emplace_back( e );
+         }
+      }
+   };
+
+}  // namespace tao::json::internal
+
+#endif

data/ext/third_party/json/include/tao/json/contrib/internal/indirect_traits.hpp

@@ -0,0 +1,76 @@
+// Copyright (c) 2018-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/json/
+
+#ifndef TAO_JSON_CONTRIB_INTERNAL_INDIRECT_TRAITS_HPP
+#define TAO_JSON_CONTRIB_INTERNAL_INDIRECT_TRAITS_HPP
+
+#include <cassert>
+
+#include "../../forward.hpp"
+#include "../../type.hpp"
+
+#include "../../events/produce.hpp"
+
+#include "../../internal/type_traits.hpp"
+
+namespace tao::json::internal
+{
+   template< typename T >
+   struct indirect_traits
+   {
+      template< typename U >
+      [[nodiscard]] static const U& add_const( const U& u )
+      {
+         return u;
+      }
+
+      template< template< typename... > class Traits >
+      [[nodiscard]] static bool is_nothing( const T& o )
+      {
+         return bool( o ) && internal::is_nothing< Traits >( add_const( *o ) );
+      }
+
+      template< template< typename... > class Traits >
+      static void assign( basic_value< Traits >& v, const T& o )
+      {
+         if( o ) {
+            v = add_const( *o );
+         }
+         else {
+            v = null;
+         }
+      }
+
+      template< template< typename... > class Traits, typename Consumer >
+      static void produce( Consumer& c, const T& o )
+      {
+         if( o ) {
+            json::events::produce< Traits >( c, add_const( *o ) );
+         }
+         else {
+            c.null();
+         }
+      }
+
+      template< template< typename... > class Traits >
+      [[nodiscard]] static bool equal( const basic_value< Traits >& lhs, const T& rhs ) noexcept
+      {
+         return rhs ? ( lhs == *rhs ) : ( lhs == null );
+      }
+
+      template< template< typename... > class Traits >
+      [[nodiscard]] static bool less_than( const basic_value< Traits >& lhs, const T& rhs ) noexcept
+      {
+         return rhs ? ( lhs < *rhs ) : ( lhs < null );
+      }
+
+      template< template< typename... > class Traits >
+      [[nodiscard]] static bool greater_than( const basic_value< Traits >& lhs, const T& rhs ) noexcept
+      {
+         return rhs ? ( lhs > *rhs ) : ( lhs > null );
+      }
+   };
+
+}  // namespace tao::json::internal
+
+#endif

data/ext/third_party/json/include/tao/json/contrib/internal/object_traits.hpp

@@ -0,0 +1,105 @@
+// Copyright (c) 2018-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/json/
+
+#ifndef TAO_JSON_CONTRIB_INTERNAL_OBJECT_TRAITS_HPP
+#define TAO_JSON_CONTRIB_INTERNAL_OBJECT_TRAITS_HPP
+
+#include <algorithm>
+#include <string>
+
+#include "../../forward.hpp"
+#include "../../type.hpp"
+
+#include "../../events/produce.hpp"
+
+namespace tao::json::internal
+{
+   template< typename T >
+   struct object_multi_traits
+   {
+      template< template< typename... > class Traits >
+      [[nodiscard]] static bool is_nothing( const T& o )
+      {
+         return o.empty();
+      }
+
+      template< template< typename... > class Traits >
+      static void assign( basic_value< Traits >& v, const T& o ) = delete;
+
+      template< template< typename... > class Traits, typename Consumer >
+      static void produce( Consumer& c, const T& o )
+      {
+         c.begin_object( o.size() );
+         for( const auto& i : o ) {
+            c.key( i.first );
+            json::events::produce< Traits >( c, i.second );
+            c.member();
+         }
+         c.end_object( o.size() );
+      }
+
+      template< template< typename... > class Traits >
+      [[nodiscard]] static bool equal( const basic_value< Traits >& lhs, const T& rhs ) noexcept
+      {
+         static const auto eq = []( const typename T::value_type& r, const std::pair< const std::string, basic_value< Traits > >& l ) {
+            return ( l.first == r.first ) && ( l.second == r.second );
+         };
+         const auto& p = lhs.skip_value_ptr();
+         if( !p.is_object() ) {
+            return false;
+         }
+         const auto& o = p.get_object();
+         return ( o.size() == rhs.size() ) && std::equal( rhs.begin(), rhs.end(), o.begin(), eq );
+      }
+
+      struct pair_less
+      {
+         template< typename L, typename R >
+         [[nodiscard]] bool operator()( const L& l, const R& r ) const noexcept
+         {
+            return ( l.first < r.first ) || ( ( l.first == r.first ) && ( l.second < r.second ) );
+         }
+      };
+
+      template< template< typename... > class Traits >
+      [[nodiscard]] static bool less_than( const basic_value< Traits >& lhs, const T& rhs ) noexcept
+      {
+         const auto& p = lhs.skip_value_ptr();
+         const auto t = p.type();
+         if( t != type::OBJECT ) {
+            return t < type::OBJECT;
+         }
+         const auto& o = p.get_object();
+         return std::lexicographical_compare( o.begin(), o.end(), rhs.begin(), rhs.end(), pair_less() );
+      }
+
+      template< template< typename... > class Traits >
+      [[nodiscard]] static bool greater_than( const basic_value< Traits >& lhs, const T& rhs ) noexcept
+      {
+         const auto& p = lhs.skip_value_ptr();
+         const auto t = p.type();
+         if( t != type::OBJECT ) {
+            return t > type::OBJECT;
+         }
+         const auto& o = p.get_object();
+         return std::lexicographical_compare( rhs.begin(), rhs.end(), o.begin(), o.end(), pair_less() );
+      }
+   };
+
+   template< typename T >
+   struct object_traits
+      : object_multi_traits< T >
+   {
+      template< template< typename... > class Traits >
+      static void assign( basic_value< Traits >& v, const T& o )
+      {
+         v.prepare_object();
+         for( const auto& i : o ) {
+            v.try_emplace( i.first, i.second );
+         }
+      }
+   };
+
+}  // namespace tao::json::internal
+
+#endif

data/ext/third_party/json/include/tao/json/contrib/internal/type_traits.hpp

@@ -0,0 +1,36 @@
+// Copyright (c) 2018-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/json/
+
+#ifndef TAO_JSON_CONTRIB_INTERNAL_TYPE_TRAITS_HPP
+#define TAO_JSON_CONTRIB_INTERNAL_TYPE_TRAITS_HPP
+
+#include "../../forward.hpp"
+
+#include "../../internal/type_traits.hpp"
+
+namespace tao::json::internal
+{
+   template< typename T, template< typename... > class Traits, typename... With >
+   inline constexpr bool use_first_ptr_as = std::is_constructible_v< T, const basic_value< Traits >&, With&... >;
+
+   template< typename T, template< typename... > class Traits, typename... With >
+   inline constexpr bool use_second_ptr_as = !use_first_ptr_as< T, Traits, With... > && std::is_move_constructible_v< T > && has_as< Traits< T >, basic_value< Traits >, With... >;
+
+   template< typename T, template< typename... > class Traits, typename... With >
+   inline constexpr bool use_third_ptr_as = !use_first_ptr_as< T, Traits, With... > && !use_second_ptr_as< T, Traits, With... > && std::is_default_constructible_v< T > && has_to< Traits< T >, basic_value< Traits >, T, With... >;
+
+   template< typename T, template< typename... > class Traits, typename... With >
+   inline constexpr bool use_fourth_ptr_as = !use_first_ptr_as< T, Traits, With... > && !use_third_ptr_as< T, Traits, With... > && std::is_copy_constructible_v< T > && has_as< Traits< T >, basic_value< Traits >, With... >;
+
+   template< typename T, template< typename... > class Traits, class Producer >
+   inline constexpr bool use_first_ptr_consume = std::is_move_constructible_v< T >&& has_consume_one< Traits, Producer, T >;
+
+   template< typename T, template< typename... > class Traits, class Producer >
+   inline constexpr bool use_second_ptr_consume = !use_first_ptr_consume< T, Traits, Producer > && std::is_default_constructible_v< T > && has_consume_two< Traits, Producer, T >;
+
+   template< typename T, template< typename... > class Traits, class Producer >
+   inline constexpr bool use_third_ptr_consume = !use_second_ptr_consume< T, Traits, Producer > && std::is_copy_constructible_v< T > && has_consume_one< Traits, Producer, T >;
+
+}  // namespace tao::json::internal
+
+#endif

data/ext/third_party/json/include/tao/json/contrib/list_traits.hpp

@@ -0,0 +1,41 @@
+// Copyright (c) 2018-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/json/
+
+#ifndef TAO_JSON_CONTRIB_LIST_TRAITS_HPP
+#define TAO_JSON_CONTRIB_LIST_TRAITS_HPP
+
+#include <list>
+
+#include "../consume.hpp"
+#include "../forward.hpp"
+
+#include "internal/array_traits.hpp"
+
+namespace tao::json
+{
+   template< typename T, typename... Ts >
+   struct list_traits
+      : internal::array_traits< std::list< T, Ts... > >
+   {
+      template< template< typename... > class Traits, typename... With >
+      static void to( const basic_value< Traits >& v, std::list< T, Ts... >& r, With&... with )
+      {
+         const auto& a = v.get_array();
+         for( const auto& i : a ) {
+            r.emplace_back( i.template as_with< T >( with... ) );
+         }
+      }
+
+      template< template< typename... > class Traits, typename Producer >
+      static void consume( Producer& parser, std::list< T, Ts... >& r )
+      {
+         auto s = parser.begin_array();
+         while( parser.element_or_end_array( s ) ) {
+            r.emplace_back( json::consume< T, Traits >( parser ) );
+         }
+      }
+   };
+
+}  // namespace tao::json
+
+#endif

data/ext/third_party/json/include/tao/json/contrib/map_traits.hpp

@@ -0,0 +1,43 @@
+// Copyright (c) 2018-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/json/
+
+#ifndef TAO_JSON_CONTRIB_MAP_TRAITS_HPP
+#define TAO_JSON_CONTRIB_MAP_TRAITS_HPP
+
+#include <map>
+#include <string>
+
+#include "../consume.hpp"
+#include "../forward.hpp"
+
+#include "internal/object_traits.hpp"
+
+namespace tao::json
+{
+   template< typename T, typename... Ts >
+   struct map_traits
+      : internal::object_traits< std::map< std::string, T, Ts... > >
+   {
+      template< template< typename... > class Traits, typename... With >
+      static void to( const basic_value< Traits >& v, std::map< std::string, T, Ts... >& r, With&... with )
+      {
+         const auto& o = v.get_object();
+         for( const auto& i : o ) {
+            r.try_emplace( i.first, i.second.template as_with< T >( with... ) );
+         }
+      }
+
+      template< template< typename... > class Traits, typename Producer >
+      static void consume( Producer& parser, std::map< std::string, T, Ts... >& v )
+      {
+         auto s = parser.begin_object();
+         while( parser.member_or_end_object( s ) ) {
+            auto k = parser.key();
+            v.try_emplace( std::move( k ), json::consume< T, Traits >( parser ) );
+         }
+      }
+   };
+
+}  // namespace tao::json
+
+#endif

data/ext/third_party/json/include/tao/json/contrib/multimap_traits.hpp

@@ -0,0 +1,43 @@
+// Copyright (c) 2018-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/json/
+
+#ifndef TAO_JSON_CONTRIB_MULTIMAP_TRAITS_HPP
+#define TAO_JSON_CONTRIB_MULTIMAP_TRAITS_HPP
+
+#include <map>
+#include <string>
+
+#include "../consume.hpp"
+#include "../forward.hpp"
+
+#include "internal/object_traits.hpp"
+
+namespace tao::json
+{
+   template< typename T, typename... Ts >
+   struct multimap_traits
+      : internal::object_multi_traits< std::multimap< std::string, T, Ts... > >
+   {
+      template< template< typename... > class Traits, typename... With >
+      static void to( const basic_value< Traits >& v, std::multimap< std::string, T, Ts... >& r, With&... with )
+      {
+         const auto& o = v.get_object();
+         for( const auto& i : o ) {
+            r.try_emplace( i.first, i.second.template as_with< T >( with... ) );
+         }
+      }
+
+      template< template< typename... > class Traits, typename Producer >
+      static void consume( Producer& parser, std::multimap< std::string, T, Ts... >& v )
+      {
+         auto s = parser.begin_object();
+         while( parser.member_or_end_object( s ) ) {
+            auto k = parser.key();
+            v.try_emplace( std::move( k ), json::consume< T, Traits >( parser ) );
+         }
+      }
+   };
+
+}  // namespace tao::json
+
+#endif

data/ext/third_party/json/include/tao/json/contrib/multiset_traits.hpp

@@ -0,0 +1,41 @@
+// Copyright (c) 2018-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/json/
+
+#ifndef TAO_JSON_CONTRIB_MULTISET_TRAITS_HPP
+#define TAO_JSON_CONTRIB_MULTISET_TRAITS_HPP
+
+#include <set>
+
+#include "../consume.hpp"
+#include "../forward.hpp"
+
+#include "internal/array_traits.hpp"
+
+namespace tao::json
+{
+   template< typename T, typename... Ts >
+   struct multiset_traits
+      : internal::array_traits< std::multiset< T, Ts... > >
+   {
+      template< template< typename... > class Traits, typename... With >
+      static void to( const basic_value< Traits >& v, std::multiset< T, Ts... >& r, With&... with )
+      {
+         const auto& a = v.get_array();
+         for( const auto& i : a ) {
+            r.emplace( i.template as_with< T >( with... ) );
+         }
+      }
+
+      template< template< typename... > class Traits, typename Producer >
+      static void consume( Producer& parser, std::multiset< T, Ts... >& r )
+      {
+         auto s = parser.begin_array();
+         while( parser.element_or_end_array( s ) ) {
+            r.emplace( json::consume< T, Traits >( parser ) );
+         }
+      }
+   };
+
+}  // namespace tao::json
+
+#endif