couchbase 3.0.3-universal-darwin-20

data/ext/third_party/json/include/tao/json/jaxn.hpp

@@ -0,0 +1,19 @@
+// Copyright (c) 2017-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/json/
+
+#ifndef TAO_JSON_JAXN_HPP
+#define TAO_JSON_JAXN_HPP
+
+#include "../json.hpp"
+
+#include "jaxn/consume_file.hpp"
+#include "jaxn/consume_string.hpp"
+#include "jaxn/from_file.hpp"
+#include "jaxn/from_input.hpp"
+#include "jaxn/from_stream.hpp"
+#include "jaxn/from_string.hpp"
+#include "jaxn/parts_parser.hpp"
+#include "jaxn/to_stream.hpp"
+#include "jaxn/to_string.hpp"
+
+#endif

data/ext/third_party/json/include/tao/json/jaxn/consume_file.hpp

@@ -0,0 +1,34 @@
+// 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_JAXN_CONSUME_FILE_HPP
+#define TAO_JSON_JAXN_CONSUME_FILE_HPP
+
+#include <filesystem>
+
+#include "../external/pegtl/file_input.hpp"
+
+#include "../consume.hpp"
+#include "../forward.hpp"
+
+#include "parts_parser.hpp"
+
+namespace tao::json::jaxn
+{
+   template< typename T, template< typename... > class Traits = traits >
+   [[nodiscard]] T consume_file( const std::filesystem::path& path )
+   {
+      jaxn::basic_parts_parser< pegtl::file_input< pegtl::tracking_mode::lazy > > pp( path );
+      return json::consume< T, Traits >( pp );
+   }
+
+   template< template< typename... > class Traits = traits, typename T >
+   void consume_file( const std::filesystem::path& path, T& t )
+   {
+      jaxn::basic_parts_parser< pegtl::file_input< pegtl::tracking_mode::lazy > > pp( path );
+      json::consume< Traits >( pp, t );
+   }
+
+}  // namespace tao::json::jaxn
+
+#endif

data/ext/third_party/json/include/tao/json/jaxn/consume_string.hpp

@@ -0,0 +1,32 @@
+// Copyright (c) 2019-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/json/
+
+#ifndef TAO_JSON_JAXN_CONSUME_STRING_HPP
+#define TAO_JSON_JAXN_CONSUME_STRING_HPP
+
+#include "../external/pegtl/string_input.hpp"
+
+#include "../consume.hpp"
+#include "../forward.hpp"
+
+#include "parts_parser.hpp"
+
+namespace tao::json::jaxn
+{
+   template< typename T, template< typename... > class Traits = traits, typename F >
+   [[nodiscard]] T consume_string( F&& string )
+   {
+      jaxn::basic_parts_parser< pegtl::memory_input< pegtl::tracking_mode::lazy, pegtl::eol::lf_crlf, const char* > > pp( string, __FUNCTION__ );
+      return json::consume< T, Traits >( pp );
+   }
+
+   template< template< typename... > class Traits = traits, typename F, typename T >
+   void consume_string( F&& string, T& t )
+   {
+      jaxn::basic_parts_parser< pegtl::memory_input< pegtl::tracking_mode::lazy, pegtl::eol::lf_crlf, const char* > > pp( string, __FUNCTION__ );
+      json::consume< Traits >( pp, t );
+   }
+
+}  // namespace tao::json::jaxn
+
+#endif

data/ext/third_party/json/include/tao/json/jaxn/events/from_file.hpp

@@ -0,0 +1,28 @@
+// Copyright (c) 2017-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/json/
+
+#ifndef TAO_JSON_JAXN_EVENTS_FROM_FILE_HPP
+#define TAO_JSON_JAXN_EVENTS_FROM_FILE_HPP
+
+#include <filesystem>
+
+#include "../internal/action.hpp"
+#include "../internal/errors.hpp"
+#include "../internal/grammar.hpp"
+
+#include "../../external/pegtl/file_input.hpp"
+
+namespace tao::json::jaxn::events
+{
+   // Events producer to parse a file containing a JAXN string representation.
+
+   template< typename Consumer >
+   void from_file( Consumer& consumer, const std::filesystem::path& path )
+   {
+      pegtl::file_input< pegtl::tracking_mode::lazy > in( path );
+      pegtl::parse< internal::grammar, internal::action, internal::errors >( in, consumer );
+   }
+
+}  // namespace tao::json::jaxn::events
+
+#endif

data/ext/third_party/json/include/tao/json/jaxn/events/from_input.hpp

@@ -0,0 +1,45 @@
+// 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_JAXN_EVENTS_FROM_INPUT_HPP
+#define TAO_JSON_JAXN_EVENTS_FROM_INPUT_HPP
+
+#include <utility>
+
+#include "../../external/pegtl/parse.hpp"
+
+#include "../internal/action.hpp"
+#include "../internal/errors.hpp"
+#include "../internal/grammar.hpp"
+
+namespace tao::json::jaxn::events
+{
+   // Events producers that parse a JAXN string representation from a PEGTL input (or something compatible).
+
+   template< typename Consumer, typename Input >
+   void from_input( Consumer& consumer, Input&& in )
+   {
+      pegtl::parse< internal::grammar, internal::action, internal::errors >( std::forward< Input >( in ), consumer );
+   }
+
+   template< typename Consumer, typename Input >
+   void from_input_embedded( Consumer& consumer, Input&& in )
+   {
+      pegtl::parse< internal::embedded, internal::action, internal::errors >( std::forward< Input >( in ), consumer );
+   }
+
+   template< typename Consumer, typename Outer, typename Input >
+   void from_input_nested( Consumer& consumer, const Outer& oi, Input&& in )
+   {
+      pegtl::parse_nested< internal::grammar, internal::action, internal::errors >( oi, std::forward< Input >( in ), consumer );
+   }
+
+   template< typename Consumer, typename Outer, typename Input >
+   void from_input_embedded_nested( Consumer& consumer, const Outer& oi, Input&& in )
+   {
+      pegtl::parse_nested< internal::embedded, internal::action, internal::errors >( oi, std::forward< Input >( in ), consumer );
+   }
+
+}  // namespace tao::json::jaxn::events
+
+#endif

data/ext/third_party/json/include/tao/json/jaxn/events/from_stream.hpp

@@ -0,0 +1,33 @@
+// Copyright (c) 2017-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/json/
+
+#ifndef TAO_JSON_JAXN_EVENTS_FROM_STREAM_HPP
+#define TAO_JSON_JAXN_EVENTS_FROM_STREAM_HPP
+
+#include <istream>
+
+#include "../../external/pegtl/internal/istream_reader.hpp"
+#include "../../external/pegtl/parse.hpp"
+
+#include "../internal/action.hpp"
+#include "../internal/errors.hpp"
+#include "../internal/grammar.hpp"
+
+namespace tao::json::jaxn::events
+{
+   template< typename Consumer >
+   void from_stream( Consumer& consumer, std::istream& stream, const char* source = nullptr, const std::size_t maximum_buffer_size = 4000 )
+   {
+      pegtl::istream_input in( stream, maximum_buffer_size, source ? source : "tao::json::events::jaxn::from_stream" );
+      pegtl::parse< internal::grammar, internal::action, internal::errors >( in, consumer );
+   }
+
+   template< typename Consumer >
+   void from_stream( Consumer& consumer, std::istream& stream, const std::string& source, const std::size_t maximum_buffer_size = 4000 )
+   {
+      from_stream( consumer, stream, source.c_str(), maximum_buffer_size );
+   }
+
+}  // namespace tao::json::jaxn::events
+
+#endif

data/ext/third_party/json/include/tao/json/jaxn/events/from_string.hpp

@@ -0,0 +1,39 @@
+// Copyright (c) 2017-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/json/
+
+#ifndef TAO_JSON_JAXN_EVENTS_FROM_STRING_HPP
+#define TAO_JSON_JAXN_EVENTS_FROM_STRING_HPP
+
+#include <string>
+#include <string_view>
+
+#include "../../external/pegtl/memory_input.hpp"
+
+#include "from_input.hpp"
+
+namespace tao::json::jaxn::events
+{
+   // Events producer to parse a JAXN string representation.
+
+   template< typename Consumer >
+   void from_string( Consumer& consumer, const char* data, const std::size_t size, const char* source = nullptr, const std::size_t byte = 0, const std::size_t line = 1, const std::size_t column = 1 )
+   {
+      pegtl::memory_input< pegtl::tracking_mode::lazy, pegtl::eol::lf_crlf, const char* > in( data, data + size, source ? source : "tao::json::jaxn::events::from_string", byte, line, column );
+      jaxn::events::from_input( consumer, std::move( in ) );
+   }
+
+   template< typename Consumer >
+   void from_string( Consumer& consumer, const char* data, const std::size_t size, const std::string& source, const std::size_t byte = 0, const std::size_t line = 1, const std::size_t column = 1 )
+   {
+      jaxn::events::from_string( consumer, data, size, source.c_str(), byte, line, column );
+   }
+
+   template< typename Consumer, typename... Ts >
+   void from_string( Consumer& consumer, const std::string_view data, Ts&&... ts )
+   {
+      jaxn::events::from_string( consumer, data.data(), data.size(), std::forward< Ts >( ts )... );
+   }
+
+}  // namespace tao::json::jaxn::events
+
+#endif

data/ext/third_party/json/include/tao/json/jaxn/events/to_pretty_stream.hpp

@@ -0,0 +1,69 @@
+// Copyright (c) 2017-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/json/
+
+#ifndef TAO_JSON_JAXN_EVENTS_TO_PRETTY_STREAM_HPP
+#define TAO_JSON_JAXN_EVENTS_TO_PRETTY_STREAM_HPP
+
+#include "../../internal/hexdump.hpp"
+
+#include "../../external/ryu.hpp"
+
+#include "../../events/to_pretty_stream.hpp"
+
+#include "../is_identifier.hpp"
+
+namespace tao::json::jaxn::events
+{
+   // Events consumer to build a JAXN string representation.
+
+   struct to_pretty_stream
+      : json::events::to_pretty_stream
+   {
+      using json::events::to_pretty_stream::to_pretty_stream;
+
+      using json::events::to_pretty_stream::number;
+
+      void number( const double v )
+      {
+         next();
+         if( !std::isfinite( v ) ) {
+            if( std::isnan( v ) ) {
+               os.write( "NaN", 3 );
+            }
+            else if( v < 0 ) {
+               os.write( "-Infinity", 9 );
+            }
+            else {
+               os.write( "Infinity", 8 );
+            }
+         }
+         else {
+            ryu::d2s_stream( os, v );
+         }
+      }
+
+      void binary( const tao::binary_view v )
+      {
+         next();
+         os.put( '$' );
+         json::internal::hexdump( os, v );
+      }
+
+      void key( const std::string_view v )
+      {
+         if( jaxn::is_identifier( v ) ) {
+            next();
+            os.write( v.data(), v.size() );
+         }
+         else {
+            string( v );
+         }
+         os.write( ": ", 2 );
+         first = true;
+         after_key = true;
+      }
+   };
+
+}  // namespace tao::json::jaxn::events
+
+#endif

data/ext/third_party/json/include/tao/json/jaxn/events/to_stream.hpp

@@ -0,0 +1,67 @@
+// Copyright (c) 2017-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/json/
+
+#ifndef TAO_JSON_JAXN_EVENTS_TO_STREAM_HPP
+#define TAO_JSON_JAXN_EVENTS_TO_STREAM_HPP
+
+#include "../../events/to_stream.hpp"
+
+#include "../../external/ryu.hpp"
+
+#include "../../internal/hexdump.hpp"
+
+#include "../is_identifier.hpp"
+
+namespace tao::json::jaxn::events
+{
+   // Events consumer to build a JAXN string representation.
+
+   struct to_stream
+      : json::events::to_stream
+   {
+      using json::events::to_stream::number;
+      using json::events::to_stream::to_stream;
+
+      void number( const double v )
+      {
+         next();
+         if( !std::isfinite( v ) ) {
+            if( std::isnan( v ) ) {
+               os << "NaN";
+            }
+            else if( v < 0 ) {
+               os << "-Infinity";
+            }
+            else {
+               os << "Infinity";
+            }
+         }
+         else {
+            ryu::d2s_stream( os, v );
+         }
+      }
+
+      void key( const std::string_view v )
+      {
+         if( jaxn::is_identifier( v ) ) {
+            next();
+            os.write( v.data(), v.size() );
+         }
+         else {
+            string( v );
+         }
+         os.put( ':' );
+         first = true;
+      }
+
+      void binary( const tao::binary_view v )
+      {
+         next();
+         os.put( '$' );
+         json::internal::hexdump( os, v );
+      }
+   };
+
+}  // namespace tao::json::jaxn::events
+
+#endif

data/ext/third_party/json/include/tao/json/jaxn/events/to_string.hpp

@@ -0,0 +1,33 @@
+// Copyright (c) 2016-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/json/
+
+#ifndef TAO_JSON_JAXN_EVENTS_TO_STRING_HPP
+#define TAO_JSON_JAXN_EVENTS_TO_STRING_HPP
+
+#include <sstream>
+#include <string>
+
+#include "to_stream.hpp"
+
+namespace tao::json::jaxn::events
+{
+   // Events consumer to build a JAXN string representation.
+
+   struct to_string
+      : to_stream
+   {
+      std::ostringstream oss;
+
+      to_string()
+         : to_stream( oss )
+      {}
+
+      [[nodiscard]] std::string value() const
+      {
+         return oss.str();
+      }
+   };
+
+}  // namespace tao::json::jaxn::events
+
+#endif

data/ext/third_party/json/include/tao/json/jaxn/from_file.hpp

@@ -0,0 +1,33 @@
+// Copyright (c) 2017-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/json/
+
+#ifndef TAO_JSON_JAXN_FROM_FILE_HPP
+#define TAO_JSON_JAXN_FROM_FILE_HPP
+
+#include <filesystem>
+#include <utility>
+
+#include "../events/to_value.hpp"
+#include "../events/transformer.hpp"
+
+#include "events/from_file.hpp"
+
+namespace tao::json::jaxn
+{
+   template< template< typename... > class Traits, template< typename... > class... Transformers >
+   [[nodiscard]] basic_value< Traits > basic_from_file( const std::filesystem::path& path )
+   {
+      json::events::transformer< json::events::to_basic_value< Traits >, Transformers... > consumer;
+      events::from_file( consumer, path );
+      return std::move( consumer.value );
+   }
+
+   template< template< typename... > class... Transformers >
+   [[nodiscard]] value from_file( const std::filesystem::path& path )
+   {
+      return basic_from_file< traits, Transformers... >( path );
+   }
+
+}  // namespace tao::json::jaxn
+
+#endif