RubyGems - couchbase - Versions diffs - 3.0.1-universal-darwin-19 → 3.0.2-universal-darwin-19 - Mend

couchbase 3.0.1-universal-darwin-19 → 3.0.2-universal-darwin-19

Files changed (1318) hide show

data/ext/third_party/json/include/tao/json/contrib/schema.hpp DELETED

@@ -1,1874 +0,0 @@
-// 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_CONTRIB_SCHEMA_HPP
-#define TAO_JSON_CONTRIB_SCHEMA_HPP
-#include <algorithm>
-#include <cmath>
-#include <cstdint>
-#include <limits>
-#include <memory>
-#include <regex>
-#include <set>
-#include <stdexcept>
-#include <string>
-#include <type_traits>
-#include "reference.hpp"
-#include "../events/compare.hpp"
-#include "../events/from_value.hpp"
-#include "../events/hash.hpp"
-#include "../pointer.hpp"
-#include "../value.hpp"
-#include "../external/pegtl/contrib/uri.hpp"
-#include "../external/pegtl/parse.hpp"
-namespace tao::json
-{
-   namespace internal
-   {
-      // TODO: Check if these grammars are correct.
-      struct local_part_label
-         : pegtl::plus< pegtl::sor< pegtl::alnum, pegtl::one< '!', '#', '$', '%', '&', '\'', '*', '+', '-', '/', '=', '?', '^', '_', '`', '{', '|', '}', '~' > > >
-      {};
-      struct local_part
-         : pegtl::list_must< local_part_label, pegtl::one< '.' > >
-      {};
-      struct hostname_label
-         : pegtl::seq< pegtl::alnum, pegtl::rep_max< 62, pegtl::ranges< 'a', 'z', 'A', 'Z', '0', '9', '-' > > >
-      {};
-      struct hostname
-         : pegtl::list_must< hostname_label, pegtl::one< '.' > >
-      {};
-      struct email
-         : pegtl::seq< local_part, pegtl::one< '@' >, hostname >
-      {};
-      template< typename Rule >
-      [[nodiscard]] bool parse( const std::string_view v )
-      {
-         pegtl::memory_input in( v.data(), v.size(), "" );
-         return pegtl::parse< pegtl::seq< Rule, pegtl::eof > >( in );
-      }
-      [[nodiscard]] inline bool parse_date_time( const std::string_view v )
-      {
-         static std::regex re( "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:[0-5]\\d:[0-5]\\d(\\.\\d+)?(Z|[+-]\\d{2}:[0-5]\\d)$" );
-         if( !std::regex_search( v.begin(), v.end(), re ) ) {
-            return false;
-         }
-         const unsigned year = ( v[ 0 ] - '0' ) * 1000 + ( v[ 1 ] - '0' ) * 100 + ( v[ 2 ] - '0' ) * 10 + ( v[ 3 ] - '0' );
-         const unsigned month = ( v[ 5 ] - '0' ) * 10 + ( v[ 6 ] - '0' );
-         const unsigned day = ( v[ 8 ] - '0' ) * 10 + ( v[ 9 ] - '0' );
-         if( month == 0 || month > 12 ) {
-            return false;
-         }
-         if( day == 0 || day > 31 ) {
-            return false;
-         }
-         if( month == 2 ) {
-            const bool is_leap_year = ( year % 4 == 0 ) && ( year % 100 != 0 || year % 400 == 0 );
-            if( day > ( is_leap_year ? 29U : 28U ) ) {
-               return false;
-            }
-         }
-         else if( day == 31 ) {
-            switch( month ) {
-               case 4:
-               case 6:
-               case 9:
-               case 11:
-                  return false;
-               default:;
-            }
-         }
-         const unsigned hour = ( v[ 11 ] - '0' ) * 10 + ( v[ 12 ] - '0' );
-         if( hour >= 24 ) {
-            return false;
-         }
-         if( *v.rbegin() != 'Z' ) {
-            const auto s = v.size();
-            const unsigned tz_hour = ( v[ s - 5 ] - '0' ) * 10 + ( v[ s - 4 ] - '0' );
-            if( tz_hour >= 24 ) {
-               return false;
-            }
-         }
-         return true;
-      }
-      [[nodiscard]] inline std::size_t unicode_size( const std::string_view v ) noexcept
-      {
-         std::size_t r = 0;
-         for( char c : v ) {
-            r += static_cast< std::size_t >( ( c & 0xC0 ) != 0x80 );
-         }
-         return r;
-      }
-      enum schema_flags
-      {
-         NONE = 0,
-         HAS_TYPE = 1 << 0,
-         NULL_ = 1 << 1,
-         BOOLEAN = 1 << 2,
-         INTEGER = 1 << 3,
-         NUMBER = 1 << 4,
-         STRING = 1 << 5,
-         ARRAY = 1 << 6,
-         OBJECT = 1 << 7,
-         HAS_ENUM = 1 << 8,
-         HAS_MULTIPLE_OF_UNSIGNED = 1 << 9,
-         HAS_MULTIPLE_OF_DOUBLE = 1 << 10,
-         HAS_MULTIPLE_OF = 3 << 9,
-         HAS_MAXIMUM_SIGNED = 1 << 11,
-         HAS_MAXIMUM_UNSIGNED = 1 << 12,
-         HAS_MAXIMUM_DOUBLE = 3 << 11,
-         HAS_MAXIMUM = 3 << 11,
-         EXCLUSIVE_MAXIMUM = 1 << 13,
-         HAS_MINIMUM_SIGNED = 1 << 14,
-         HAS_MINIMUM_UNSIGNED = 1 << 15,
-         HAS_MINIMUM_DOUBLE = 3 << 14,
-         HAS_MINIMUM = 3 << 14,
-         EXCLUSIVE_MINIMUM = 1 << 16,
-         HAS_MAX_LENGTH = 1 << 17,
-         HAS_MIN_LENGTH = 1 << 18,
-         HAS_MAX_ITEMS = 1 << 19,
-         HAS_MIN_ITEMS = 1 << 20,
-         HAS_UNIQUE_ITEMS = 1 << 21,
-         HAS_MAX_PROPERTIES = 1 << 22,
-         HAS_MIN_PROPERTIES = 1 << 23,
-         NO_ADDITIONAL_PROPERTIES = 1 << 24,
-         HAS_DEPENDENCIES = 1 << 25
-      };
-      enum class schema_format
-      {
-         none,
-         date_time,
-         email,
-         hostname,
-         ipv4,
-         ipv6,
-         uri
-      };
-      [[nodiscard]] inline constexpr schema_flags operator|( const schema_flags lhs, const schema_flags rhs ) noexcept
-      {
-         return static_cast< schema_flags >( static_cast< std::underlying_type< schema_flags >::type >( lhs ) | static_cast< std::underlying_type< schema_flags >::type >( rhs ) );
-      }
-      union schema_limit
-      {
-         std::int64_t i;
-         std::uint64_t u;
-         double d;
-      };
-      template< template< typename... > class Traits >
-      class schema_container;
-      template< template< typename... > class Traits >
-      struct schema_node
-      {
-         const schema_container< Traits >* m_container;
-         const basic_value< Traits >* m_value;
-         const basic_value< Traits >* m_all_of = nullptr;
-         const basic_value< Traits >* m_any_of = nullptr;
-         const basic_value< Traits >* m_one_of = nullptr;
-         const basic_value< Traits >* m_not = nullptr;
-         const basic_value< Traits >* m_items = nullptr;
-         const basic_value< Traits >* m_additional_items = nullptr;
-         const basic_value< Traits >* m_properties = nullptr;
-         const basic_value< Traits >* m_additional_properties = nullptr;
-         std::map< std::string, std::set< std::string > > m_property_dependencies;
-         std::map< std::string, const basic_value< Traits >* > m_schema_dependencies;
-         std::vector< std::pair< std::regex, const basic_value< Traits >* > > m_pattern_properties;
-         std::set< const basic_value< Traits >* > m_referenced_pointers;
-         // number
-         schema_limit m_multiple_of;
-         schema_limit m_maximum;
-         schema_limit m_minimum;
-         // string
-         std::uint64_t m_max_length;
-         std::uint64_t m_min_length;
-         std::unique_ptr< std::regex > m_pattern;
-         // array
-         std::uint64_t m_max_items;
-         std::uint64_t m_min_items;
-         // object
-         std::uint64_t m_max_properties;
-         std::uint64_t m_min_properties;
-         std::set< std::string > m_required;
-         schema_flags m_flags = NONE;
-         schema_format m_format = schema_format::none;
-         void add_type( const schema_flags v )
-         {
-            if( ( m_flags & v ) != 0 ) {
-               throw std::runtime_error( "invalid JSON Schema: duplicate primitive type" );
-            }
-            m_flags = m_flags | v;
-         }
-         void add_type( const std::string_view v )
-         {
-            if( !v.empty() ) {
-               switch( v[ 0 ] ) {
-                  case 'n':
-                     if( v == "number" ) {
-                        return add_type( NUMBER );
-                     }
-                     else if( v == "null" ) {
-                        return add_type( NULL_ );
-                     }
-                     break;
-                  case 'b':
-                     if( v == "boolean" ) {
-                        return add_type( BOOLEAN );
-                     }
-                     break;
-                  case 'i':
-                     if( v == "integer" ) {
-                        return add_type( INTEGER );
-                     }
-                     break;
-                  case 's':
-                     if( v == "string" ) {
-                        return add_type( STRING );
-                     }
-                     break;
-                  case 'a':
-                     if( v == "array" ) {
-                        return add_type( ARRAY );
-                     }
-                     break;
-                  case 'o':
-                     if( v == "object" ) {
-                        return add_type( OBJECT );
-                     }
-                     break;
-               }
-            }
-            throw std::runtime_error( "invalid JSON Schema: invalid primitive type '" + std::string( v ) + '\'' );
-         }
-         [[nodiscard]] const basic_value< Traits >* find( const char* s ) const
-         {
-            const auto* p = m_value->find( s );
-            if( p != nullptr ) {
-               p = &p->skip_value_ptr();
-            }
-            return p;
-         }
-         schema_node( const schema_container< Traits >* c, const basic_value< Traits >& v )
-            : m_container( c ),
-              m_value( &v )
-         {
-            // general
-            if( !m_value->is_object() ) {
-               throw std::runtime_error( "invalid JSON Schema: a schema must be of type 'object'" );
-            }
-            // title
-            if( const auto* p = find( "title" ) ) {
-               if( !p->is_string() ) {
-                  throw std::runtime_error( "invalid JSON Schema: \"title\" must be of type 'string'" );
-               }
-            }
-            // description
-            if( const auto* p = find( "description" ) ) {
-               if( !p->is_string() ) {
-                  throw std::runtime_error( "invalid JSON Schema: \"description\" must be of type 'string'" );
-               }
-            }
-            // type
-            if( const auto* p = find( "type" ) ) {
-               switch( p->type() ) {
-                  case type::STRING:
-                     add_type( p->get_string_type() );
-                     break;
-                  case type::ARRAY:
-                     for( const auto& e : p->get_array() ) {
-                        if( !e.is_string() ) {
-                           throw std::runtime_error( "invalid JSON Schema: elements in array \"type\" must be of type 'string'" );
-                        }
-                        add_type( e.get_string_type() );
-                     }
-                     break;
-                  default:
-                     throw std::runtime_error( "invalid JSON Schema: \"type\" must be of type 'string' or 'array'" );
-               }
-               m_flags = m_flags | HAS_TYPE;
-            }
-            // enum
-            if( const auto* p = find( "enum" ) ) {
-               if( !p->is_array() ) {
-                  throw std::runtime_error( "invalid JSON Schema: \"enum\" must be of type 'array'" );
-               }
-               m_flags = m_flags | HAS_ENUM;
-            }
-            // const
-            // TODO: Implement me!
-            // allOf
-            if( const auto* p = find( "allOf" ) ) {
-               if( !p->is_array() ) {
-                  throw std::runtime_error( "invalid JSON Schema: \"allOf\" must be of type 'array'" );
-               }
-               if( p->get_array().empty() ) {
-                  throw std::runtime_error( "invalid JSON Schema: \"allOf\" must have at least one element" );
-               }
-               for( const auto& e : p->get_array() ) {
-                  m_referenced_pointers.insert( &e.skip_value_ptr() );
-               }
-               m_all_of = p;
-            }
-            // anyOf
-            if( const auto* p = find( "anyOf" ) ) {
-               if( !p->is_array() ) {
-                  throw std::runtime_error( "invalid JSON Schema: \"anyOf\" must be of type 'array'" );
-               }
-               if( p->get_array().empty() ) {
-                  throw std::runtime_error( "invalid JSON Schema: \"anyOf\" must have at least one element" );
-               }
-               for( const auto& e : p->get_array() ) {
-                  m_referenced_pointers.insert( &e.skip_value_ptr() );
-               }
-               m_any_of = p;
-            }
-            // oneOf
-            if( const auto* p = find( "oneOf" ) ) {
-               if( !p->is_array() ) {
-                  throw std::runtime_error( "invalid JSON Schema: \"oneOf\" must be of type 'array'" );
-               }
-               if( p->get_array().empty() ) {
-                  throw std::runtime_error( "invalid JSON Schema: \"oneOf\" must have at least one element" );
-               }
-               for( const auto& e : p->get_array() ) {
-                  m_referenced_pointers.insert( &e.skip_value_ptr() );
-               }
-               m_one_of = p;
-            }
-            // not
-            if( const auto* p = find( "not" ) ) {
-               m_referenced_pointers.insert( p );
-               m_not = p;
-            }
-            // dependentSchemas
-            // TODO: Implement me!
-            // definitions
-            if( const auto* p = find( "definitions" ) ) {
-               if( !p->is_object() ) {
-                  throw std::runtime_error( "invalid JSON Schema: \"definitions\" must be of type 'object'" );
-               }
-               for( const auto& e : p->get_object() ) {
-                  m_referenced_pointers.insert( &e.second.skip_value_ptr() );
-               }
-            }
-            // multipleOf
-            if( const auto* p = find( "multipleOf" ) ) {
-               switch( p->type() ) {
-                  case type::SIGNED: {
-                     const auto i = p->get_signed();
-                     if( i <= 0 ) {
-                        throw std::runtime_error( "invalid JSON Schema: \"multipleOf\" must be strictly greater than zero" );
-                     }
-                     m_multiple_of.u = i;
-                     m_flags = m_flags | HAS_MULTIPLE_OF_UNSIGNED;
-                  } break;
-                  case type::UNSIGNED: {
-                     const auto u = p->get_unsigned();
-                     if( u == 0 ) {
-                        throw std::runtime_error( "invalid JSON Schema: \"multipleOf\" must be strictly greater than zero" );
-                     }
-                     m_multiple_of.u = u;
-                     m_flags = m_flags | HAS_MULTIPLE_OF_UNSIGNED;
-                  } break;
-                  case type::DOUBLE: {
-                     const auto d = p->get_double();
-                     if( d <= 0 ) {
-                        throw std::runtime_error( "invalid JSON Schema: \"multipleOf\" must be strictly greater than zero" );
-                     }
-                     m_multiple_of.d = d;
-                     m_flags = m_flags | HAS_MULTIPLE_OF_DOUBLE;
-                  } break;
-                  default:
-                     throw std::runtime_error( "invalid JSON Schema: \"multipleOf\" must be of type 'number'" );
-               }
-            }
-            // maximum
-            if( const auto* p = find( "maximum" ) ) {
-               switch( p->type() ) {
-                  case type::SIGNED:
-                     m_maximum.i = p->get_signed();
-                     m_flags = m_flags | HAS_MAXIMUM_SIGNED;
-                     break;
-                  case type::UNSIGNED:
-                     m_maximum.u = p->get_unsigned();
-                     m_flags = m_flags | HAS_MAXIMUM_UNSIGNED;
-                     break;
-                  case type::DOUBLE:
-                     m_maximum.d = p->get_double();
-                     m_flags = m_flags | HAS_MAXIMUM_DOUBLE;
-                     break;
-                  default:
-                     throw std::runtime_error( "invalid JSON Schema: \"maximum\" must be of type 'number'" );
-               }
-            }
-            // exclusiveMaximum
-            if( const auto* p = find( "exclusiveMaximum" ) ) {
-               if( !p->is_boolean() ) {
-                  throw std::runtime_error( "invalid JSON Schema: \"exclusiveMaximum\" must be of type 'boolean'" );
-               }
-               if( ( m_flags & HAS_MAXIMUM ) == 0 ) {
-                  throw std::runtime_error( "invalid JSON Schema: \"exclusiveMaximum\" requires presence of \"maximum\"" );
-               }
-               if( p->get_boolean() ) {
-                  m_flags = m_flags | EXCLUSIVE_MAXIMUM;
-               }
-            }
-            // minimum
-            if( const auto* p = find( "minimum" ) ) {
-               switch( p->type() ) {
-                  case type::SIGNED:
-                     m_minimum.i = p->get_signed();
-                     m_flags = m_flags | HAS_MINIMUM_SIGNED;
-                     break;
-                  case type::UNSIGNED:
-                     m_minimum.u = p->get_unsigned();
-                     m_flags = m_flags | HAS_MINIMUM_UNSIGNED;
-                     break;
-                  case type::DOUBLE:
-                     m_minimum.d = p->get_double();
-                     m_flags = m_flags | HAS_MINIMUM_DOUBLE;
-                     break;
-                  default:
-                     throw std::runtime_error( "invalid JSON Schema: \"minimum\" must be of type 'number'" );
-               }
-            }
-            // exclusiveMinimum
-            if( const auto* p = find( "exclusiveMinimum" ) ) {
-               if( !p->is_boolean() ) {
-                  throw std::runtime_error( "invalid JSON Schema: \"exclusiveMinimum\" must be of type 'boolean'" );
-               }
-               if( ( m_flags & HAS_MINIMUM ) == 0 ) {
-                  throw std::runtime_error( "invalid JSON Schema: \"exclusiveMinimum\" requires presence of \"minimum\"" );
-               }
-               if( p->get_boolean() ) {
-                  m_flags = m_flags | EXCLUSIVE_MINIMUM;
-               }
-            }
-            // maxLength
-            if( const auto* p = find( "maxLength" ) ) {
-               switch( p->type() ) {
-                  case type::SIGNED: {
-                     const auto i = p->get_signed();
-                     if( i < 0 ) {
-                        throw std::runtime_error( "invalid JSON Schema: \"maxLength\" must be greater than or equal to zero" );
-                     }
-                     m_max_length = i;
-                     m_flags = m_flags | HAS_MAX_LENGTH;
-                  } break;
-                  case type::UNSIGNED:
-                     m_max_length = p->get_unsigned();
-                     m_flags = m_flags | HAS_MAX_LENGTH;
-                     break;
-                  default:
-                     throw std::runtime_error( "invalid JSON Schema: \"maxLength\" must be of type 'integer'" );
-               }
-            }
-            // minLength
-            if( const auto* p = find( "minLength" ) ) {
-               switch( p->type() ) {
-                  case type::SIGNED: {
-                     const auto i = p->get_signed();
-                     if( i < 0 ) {
-                        throw std::runtime_error( "invalid JSON Schema: \"minLength\" must be greater than or equal to zero" );
-                     }
-                     if( i > 0 ) {
-                        m_min_length = i;
-                        m_flags = m_flags | HAS_MIN_LENGTH;
-                     }
-                  } break;
-                  case type::UNSIGNED: {
-                     const auto u = p->get_unsigned();
-                     if( u > 0 ) {
-                        m_min_length = u;
-                        m_flags = m_flags | HAS_MIN_LENGTH;
-                     }
-                  } break;
-                  default:
-                     throw std::runtime_error( "invalid JSON Schema: \"minLength\" must be of type 'integer'" );
-               }
-            }
-            // pattern
-            if( const auto* p = find( "pattern" ) ) {
-               if( !p->is_string() ) {
-                  throw std::runtime_error( "invalid JSON Schema: \"pattern\" must be of type 'string'" );
-               }
-               try {
-                  m_pattern = std::make_unique< std::regex >( p->get_string() );
-               }
-               catch( const std::regex_error& e ) {
-                  throw std::runtime_error( "invalid JSON Schema: \"pattern\" must be a regular expression: " + std::string( e.what() ) );
-               }
-            }
-            // format
-            // TODO: offer an option to disable "format" support?
-            if( const auto* p = find( "format" ) ) {
-               if( !p->is_string() ) {
-                  throw std::runtime_error( "invalid JSON Schema: \"format\" must be of type 'string'" );
-               }
-               const auto& s = p->get_string();
-               if( s == "date-time" ) {
-                  m_format = schema_format::date_time;
-               }
-               else if( s == "email" ) {
-                  m_format = schema_format::email;
-               }
-               else if( s == "hostname" ) {
-                  m_format = schema_format::hostname;
-               }
-               else if( s == "ipv4" ) {
-                  m_format = schema_format::ipv4;
-               }
-               else if( s == "ipv6" ) {
-                  m_format = schema_format::ipv6;
-               }
-               else if( s == "uri" ) {
-                  m_format = schema_format::uri;
-               }
-               // unknown "format" values are ignored
-            }
-            // items
-            if( const auto* p = find( "items" ) ) {
-               if( p->is_array() ) {
-                  for( const auto& e : p->get_array() ) {
-                     m_referenced_pointers.insert( &e.skip_value_ptr() );
-                  }
-               }
-               else if( p->is_object() ) {
-                  m_referenced_pointers.insert( p );
-               }
-               else {
-                  throw std::runtime_error( "invalid JSON Schema: \"items\" must be of type 'object' or 'array'" );
-               }
-               m_items = p;
-            }
-            // additionalItems
-            if( const auto* p = find( "additionalItems" ) ) {
-               if( p->is_object() ) {
-                  m_referenced_pointers.insert( p );
-               }
-               else if( !p->is_boolean() ) {
-                  throw std::runtime_error( "invalid JSON Schema: \"additionalItems\" must be of type 'boolean' or 'object'" );
-               }
-               m_additional_items = p;
-            }
-            // unevaluatedItems
-            // TODO: Implement me!
-            // contains
-            // TODO: Implement me!
-            // maxItems
-            if( const auto* p = find( "maxItems" ) ) {
-               switch( p->type() ) {
-                  case type::SIGNED: {
-                     const auto i = p->get_signed();
-                     if( i < 0 ) {
-                        throw std::runtime_error( "invalid JSON Schema: \"maxItems\" must be greater than or equal to zero" );
-                     }
-                     m_max_items = i;
-                     m_flags = m_flags | HAS_MAX_ITEMS;
-                  } break;
-                  case type::UNSIGNED:
-                     m_max_items = p->get_unsigned();
-                     m_flags = m_flags | HAS_MAX_ITEMS;
-                     break;
-                  default:
-                     throw std::runtime_error( "invalid JSON Schema: \"maxItems\" must be of type 'integer'" );
-               }
-            }
-            // minItems
-            if( const auto* p = find( "minItems" ) ) {
-               switch( p->type() ) {
-                  case type::SIGNED: {
-                     const auto i = p->get_signed();
-                     if( i < 0 ) {
-                        throw std::runtime_error( "invalid JSON Schema: \"minItems\" must be greater than or equal to zero" );
-                     }
-                     m_min_items = i;
-                     m_flags = m_flags | HAS_MIN_ITEMS;
-                  } break;
-                  case type::UNSIGNED:
-                     m_min_items = p->get_unsigned();
-                     m_flags = m_flags | HAS_MIN_ITEMS;
-                     break;
-                  default:
-                     throw std::runtime_error( "invalid JSON Schema: \"minItems\" must be of type 'integer'" );
-               }
-            }
-            // uniqueItems
-            if( const auto* p = find( "uniqueItems" ) ) {
-               if( p->get_boolean() ) {
-                  m_flags = m_flags | HAS_UNIQUE_ITEMS;
-               }
-            }
-            // maxContains
-            // TODO: Implement me!
-            // minContains
-            // TODO: Implement me!
-            // maxProperties
-            if( const auto* p = find( "maxProperties" ) ) {
-               switch( p->type() ) {
-                  case type::SIGNED: {
-                     const auto i = p->get_signed();
-                     if( i < 0 ) {
-                        throw std::runtime_error( "invalid JSON Schema: \"maxProperties\" must be greater than or equal to zero" );
-                     }
-                     m_max_properties = i;
-                     m_flags = m_flags | HAS_MAX_PROPERTIES;
-                  } break;
-                  case type::UNSIGNED:
-                     m_max_properties = p->get_unsigned();
-                     m_flags = m_flags | HAS_MAX_PROPERTIES;
-                     break;
-                  default:
-                     throw std::runtime_error( "invalid JSON Schema: \"maxProperties\" must be of type 'integer'" );
-               }
-            }
-            // minProperties
-            if( const auto* p = find( "minProperties" ) ) {
-               switch( p->type() ) {
-                  case type::SIGNED: {
-                     const auto i = p->get_signed();
-                     if( i < 0 ) {
-                        throw std::runtime_error( "invalid JSON Schema: \"minProperties\" must be greater than or equal to zero" );
-                     }
-                     m_min_properties = i;
-                     m_flags = m_flags | HAS_MIN_PROPERTIES;
-                  } break;
-                  case type::UNSIGNED:
-                     m_min_properties = p->get_unsigned();
-                     m_flags = m_flags | HAS_MIN_PROPERTIES;
-                     break;
-                  default:
-                     throw std::runtime_error( "invalid JSON Schema: \"minProperties\" must be of type 'integer'" );
-               }
-            }
-            // required
-            if( const auto* p = find( "required" ) ) {
-               if( !p->is_array() ) {
-                  throw std::runtime_error( "invalid JSON Schema: \"required\" must be of type 'array'" );
-               }
-               if( p->get_array().empty() ) {
-                  throw std::runtime_error( "invalid JSON Schema: \"required\" must have at least one element" );
-               }
-               for( const auto& e : p->get_array() ) {
-                  if( !m_required.insert( e.get_string() ).second ) {
-                     throw std::runtime_error( "invalid JSON Schema: duplicate required key" );
-                  }
-               }
-            }
-            // dependentRequired
-            // TODO: Implement me!
-            // properties
-            if( const auto* p = find( "properties" ) ) {
-               if( !p->is_object() ) {
-                  throw std::runtime_error( "invalid JSON Schema: \"properties\" must be of type 'object'" );
-               }
-               for( const auto& e : p->get_object() ) {
-                  m_referenced_pointers.insert( &e.second.skip_value_ptr() );
-               }
-               m_properties = p;
-            }
-            // patternProperties
-            if( const auto* p = find( "patternProperties" ) ) {
-               if( !p->is_object() ) {
-                  throw std::runtime_error( "invalid JSON Schema: \"patternProperties\" must be of type 'object'" );
-               }
-               for( const auto& e : p->get_object() ) {
-                  try {
-                     m_pattern_properties.emplace_back( std::regex( e.first ), &e.second.skip_value_ptr() );
-                  }
-                  catch( const std::regex_error& ex ) {
-                     throw std::runtime_error( "invalid JSON Schema: keys in object \"patternProperties\" must be regular expressions: " + std::string( ex.what() ) );
-                  }
-                  m_referenced_pointers.insert( &e.second.skip_value_ptr() );
-               }
-            }
-            // additionalProperties
-            if( const auto* p = find( "additionalProperties" ) ) {
-               const type t = p->type();
-               if( t == type::OBJECT ) {
-                  m_referenced_pointers.insert( p );
-               }
-               else if( t != type::BOOLEAN ) {
-                  throw std::runtime_error( "invalid JSON Schema: \"additionalProperties\" must be of type 'boolean' or 'object'" );
-               }
-               m_additional_properties = p;
-            }
-            // unevaluatedProperties
-            // TODO: Implement me!
-            // dependencies
-            if( const auto* p = find( "dependencies" ) ) {
-               if( !p->is_object() ) {
-                  throw std::runtime_error( "invalid JSON Schema: \"dependencies\" must be of type 'object'" );
-               }
-               for( const auto& e : p->get_object() ) {
-                  const auto* p2 = &e.second.skip_value_ptr();
-                  if( p2->is_object() ) {
-                     m_schema_dependencies.emplace( e.first, p2 );
-                     m_referenced_pointers.insert( p2 );
-                  }
-                  else if( p2->is_array() ) {
-                     if( p2->get_array().empty() ) {
-                        throw std::runtime_error( "invalid JSON Schema: values in object \"dependencies\" of type 'array' must have at least one element" );
-                     }
-                     std::set< std::string > s;
-                     for( const auto& r : p2->get_array() ) {
-                        if( !r.is_string() ) {
-                           throw std::runtime_error( "invalid JSON Schema: values in object \"dependencies\" of type 'array' must contain elements of type 'string'" );
-                        }
-                        if( !s.emplace( r.get_string() ).second ) {
-                           throw std::runtime_error( "invalid JSON Schema: values in object \"dependencies\" of type 'array' must contain unique elements of type 'string'" );
-                        }
-                     }
-                     m_property_dependencies.emplace( e.first, std::move( s ) );
-                  }
-                  else {
-                     throw std::runtime_error( "invalid JSON Schema: values in object \"dependencies\" must be of type 'object' or 'array'" );
-                  }
-               }
-               if( !p->get_object().empty() ) {
-                  m_flags = m_flags | HAS_DEPENDENCIES;
-               }
-            }
-            // default
-            if( const auto* p = find( "default" ) ) {
-               // TODO: the value should validate against the JSON Schema itself
-            }
-         }
-         schema_node( const schema_node& ) = delete;
-         schema_node( schema_node&& ) = delete;
-         ~schema_node() = default;
-         void operator=( const schema_node& ) = delete;
-         void operator=( schema_node&& ) = delete;
-         [[nodiscard]] const std::set< const basic_value< Traits >* >& referenced_pointers() const noexcept
-         {
-            return m_referenced_pointers;
-         }
-      };
-      template< template< typename... > class Traits >
-      class schema_consumer
-      {
-      private:
-         const std::shared_ptr< const schema_container< Traits > > m_container;
-         const schema_node< Traits >* const m_node;
-         std::vector< std::unique_ptr< events_compare< Traits > > > m_enum;
-         std::unique_ptr< events::hash > m_hash;
-         std::set< std::string > m_unique;
-         std::set< std::string > m_keys;
-         std::vector< std::size_t > m_count;
-         std::vector< std::unique_ptr< schema_consumer > > m_properties;
-         std::vector< std::unique_ptr< schema_consumer > > m_all_of;
-         std::vector< std::unique_ptr< schema_consumer > > m_any_of;
-         std::vector< std::unique_ptr< schema_consumer > > m_one_of;
-         std::map< std::string, std::unique_ptr< schema_consumer > > m_schema_dependencies;
-         std::unique_ptr< schema_consumer > m_not;
-         std::unique_ptr< schema_consumer > m_item;
-         bool m_match = true;
-         void validate_type( const schema_flags t )
-         {
-            if( !m_count.empty() ) {
-               return;
-            }
-            if( ( m_node->m_flags & HAS_TYPE ) == 0 ) {
-               return;
-            }
-            if( ( m_node->m_flags & t ) == 0 ) {
-               m_match = false;
-            }
-         }
-         // note: lambda returns true if validation failure detected
-         template< typename F >
-         void validate_enum( F&& f )
-         {
-            assert( m_match );
-            if( m_node->m_flags & HAS_ENUM ) {
-               m_enum.erase( std::remove_if( m_enum.begin(), m_enum.end(), [ & ]( const std::unique_ptr< events_compare< Traits > >& p ) { return f( *p ); } ), m_enum.end() );
-               if( m_enum.empty() ) {
-                  m_match = false;
-               }
-            }
-         }
-         template< typename F >
-         void validate_item( F&& f )
-         {
-            if( m_item ) {
-               if( f( m_item ) ) {
-                  m_match = false;
-               }
-            }
-         }
-         template< typename F >
-         void validate_properties( F&& f )
-         {
-            for( auto& p : m_properties ) {
-               if( f( p ) ) {
-                  m_match = false;
-                  break;
-               }
-            }
-         }
-         template< typename F >
-         void validate_schema_dependencies( F&& f )
-         {
-            auto it = m_schema_dependencies.begin();
-            while( it != m_schema_dependencies.end() ) {
-               if( f( it->second ) ) {
-                  it = m_schema_dependencies.erase( it );
-               }
-               else {
-                  ++it;
-               }
-            }
-         }
-         template< typename F >
-         void validate_all_of( F&& f )
-         {
-            for( auto& p : m_all_of ) {
-               if( f( p ) ) {
-                  m_match = false;
-                  break;
-               }
-            }
-         }
-         template< typename F >
-         void validate_any_of( F&& f )
-         {
-            if( !m_any_of.empty() ) {
-               m_any_of.erase( std::remove_if( m_any_of.begin(), m_any_of.end(), f ), m_any_of.end() );
-               if( m_any_of.empty() ) {
-                  m_match = false;
-               }
-            }
-         }
-         template< typename F >
-         void validate_one_of( F&& f )
-         {
-            if( !m_one_of.empty() ) {
-               m_one_of.erase( std::remove_if( m_one_of.begin(), m_one_of.end(), f ), m_one_of.end() );
-               if( m_one_of.empty() ) {
-                  m_match = false;
-               }
-            }
-         }
-         template< typename F >
-         void validate_not( F&& f )
-         {
-            if( m_not ) {
-               if( f( m_not ) ) {
-                  m_not.reset();
-               }
-            }
-         }
-         // note: lambda returns true if validation failure detected
-         template< typename F >
-         void validate_collections( F&& f )
-         {
-            assert( m_match );
-            const auto f2 = [ & ]( const std::unique_ptr< schema_consumer >& p ) { return f( *p ); };
-            if( m_match ) {
-               validate_item( f2 );
-            }
-            if( m_match ) {
-               validate_properties( f2 );
-            }
-            if( m_match ) {
-               validate_all_of( f2 );
-            }
-            if( m_match ) {
-               validate_any_of( f2 );
-            }
-            if( m_match ) {
-               validate_one_of( f2 );
-            }
-            if( m_match ) {
-               validate_not( f2 );
-            }
-            if( m_match ) {
-               validate_schema_dependencies( f2 );
-            }
-         }
-         [[nodiscard]] static bool is_multiple_of( const double v, const double d )
-         {
-            const auto r = std::fmod( v, d );
-            if( std::fabs( r ) < std::numeric_limits< double >::epsilon() ) {
-               return true;
-            }
-            if( std::fabs( r - d ) < std::numeric_limits< double >::epsilon() ) {
-               return true;
-            }
-            return false;
-         }
-         void validate_multiple_of( const std::int64_t v )
-         {
-            switch( m_node->m_flags & HAS_MULTIPLE_OF ) {
-               case HAS_MULTIPLE_OF_UNSIGNED:
-                  if( v < 0 ) {
-                     if( ( -v % m_node->m_multiple_of.u ) != 0 ) {
-                        m_match = false;
-                     }
-                  }
-                  else {
-                     if( ( v % m_node->m_multiple_of.u ) != 0 ) {
-                        m_match = false;
-                     }
-                  }
-                  break;
-               case HAS_MULTIPLE_OF_DOUBLE:
-                  if( !is_multiple_of( double( v ), m_node->m_multiple_of.d ) ) {
-                     m_match = false;
-                  }
-                  break;
-            }
-         }
-         void validate_multiple_of( const std::uint64_t v )
-         {
-            switch( m_node->m_flags & HAS_MULTIPLE_OF ) {
-               case HAS_MULTIPLE_OF_UNSIGNED:
-                  if( ( v % m_node->m_multiple_of.u ) != 0 ) {
-                     m_match = false;
-                  }
-                  break;
-               case HAS_MULTIPLE_OF_DOUBLE:
-                  if( !is_multiple_of( double( v ), m_node->m_multiple_of.d ) ) {
-                     m_match = false;
-                  }
-                  break;
-            }
-         }
-         void validate_multiple_of( const double v )
-         {
-            switch( m_node->m_flags & HAS_MULTIPLE_OF ) {
-               case HAS_MULTIPLE_OF_UNSIGNED:
-                  if( !is_multiple_of( v, double( m_node->m_multiple_of.u ) ) ) {
-                     m_match = false;
-                  }
-                  break;
-               case HAS_MULTIPLE_OF_DOUBLE:
-                  if( !is_multiple_of( v, m_node->m_multiple_of.d ) ) {
-                     m_match = false;
-                  }
-                  break;
-            }
-         }
-         void validate_number( const std::int64_t v )
-         {
-            validate_multiple_of( v );
-            switch( m_node->m_flags & ( HAS_MAXIMUM | EXCLUSIVE_MAXIMUM ) ) {
-               case HAS_MAXIMUM_SIGNED:
-                  if( v > m_node->m_maximum.i ) {
-                     m_match = false;
-                  }
-                  break;
-               case HAS_MAXIMUM_SIGNED | EXCLUSIVE_MAXIMUM:
-                  if( v >= m_node->m_maximum.i ) {
-                     m_match = false;
-                  }
-                  break;
-               case HAS_MAXIMUM_UNSIGNED:
-                  if( v >= 0 && static_cast< std::uint64_t >( v ) > m_node->m_maximum.u ) {
-                     m_match = false;
-                  }
-                  break;
-               case HAS_MAXIMUM_UNSIGNED | EXCLUSIVE_MAXIMUM:
-                  if( v >= 0 && static_cast< std::uint64_t >( v ) >= m_node->m_maximum.u ) {
-                     m_match = false;
-                  }
-                  break;
-               case HAS_MAXIMUM_DOUBLE:
-                  if( v > m_node->m_maximum.d ) {
-                     m_match = false;
-                  }
-                  break;
-               case HAS_MAXIMUM_DOUBLE | EXCLUSIVE_MAXIMUM:
-                  if( v >= m_node->m_maximum.d ) {
-                     m_match = false;
-                  }
-                  break;
-            }
-            switch( m_node->m_flags & ( HAS_MINIMUM | EXCLUSIVE_MINIMUM ) ) {
-               case HAS_MINIMUM_SIGNED:
-                  if( v < m_node->m_minimum.i ) {
-                     m_match = false;
-                  }
-                  break;
-               case HAS_MINIMUM_SIGNED | EXCLUSIVE_MINIMUM:
-                  if( v <= m_node->m_minimum.i ) {
-                     m_match = false;
-                  }
-                  break;
-               case HAS_MINIMUM_UNSIGNED:
-                  if( v < 0 || static_cast< std::uint64_t >( v ) < m_node->m_minimum.u ) {
-                     m_match = false;
-                  }
-                  break;
-               case HAS_MINIMUM_UNSIGNED | EXCLUSIVE_MINIMUM:
-                  if( v < 0 || static_cast< std::uint64_t >( v ) <= m_node->m_minimum.u ) {
-                     m_match = false;
-                  }
-                  break;
-               case HAS_MINIMUM_DOUBLE:
-                  if( v < m_node->m_minimum.d ) {
-                     m_match = false;
-                  }
-                  break;
-               case HAS_MINIMUM_DOUBLE | EXCLUSIVE_MINIMUM:
-                  if( v <= m_node->m_minimum.d ) {
-                     m_match = false;
-                  }
-                  break;
-            }
-         }
-         void validate_number( const std::uint64_t v )
-         {
-            validate_multiple_of( v );
-            switch( m_node->m_flags & ( HAS_MAXIMUM | EXCLUSIVE_MAXIMUM ) ) {
-               case HAS_MAXIMUM_SIGNED:
-                  if( m_node->m_maximum.i < 0 || v > static_cast< std::uint64_t >( m_node->m_maximum.i ) ) {
-                     m_match = false;
-                  }
-                  break;
-               case HAS_MAXIMUM_SIGNED | EXCLUSIVE_MAXIMUM:
-                  if( m_node->m_maximum.i < 0 || v >= static_cast< std::uint64_t >( m_node->m_maximum.i ) ) {
-                     m_match = false;
-                  }
-                  break;
-               case HAS_MAXIMUM_UNSIGNED:
-                  if( v > m_node->m_maximum.u ) {
-                     m_match = false;
-                  }
-                  break;
-               case HAS_MAXIMUM_UNSIGNED | EXCLUSIVE_MAXIMUM:
-                  if( v >= m_node->m_maximum.u ) {
-                     m_match = false;
-                  }
-                  break;
-               case HAS_MAXIMUM_DOUBLE:
-                  if( v > m_node->m_maximum.d ) {
-                     m_match = false;
-                  }
-                  break;
-               case HAS_MAXIMUM_DOUBLE | EXCLUSIVE_MAXIMUM:
-                  if( v >= m_node->m_maximum.d ) {
-                     m_match = false;
-                  }
-                  break;
-            }
-            switch( m_node->m_flags & ( HAS_MINIMUM | EXCLUSIVE_MINIMUM ) ) {
-               case HAS_MINIMUM_SIGNED:
-                  if( m_node->m_minimum.i >= 0 && v < static_cast< std::uint64_t >( m_node->m_minimum.i ) ) {
-                     m_match = false;
-                  }
-                  break;
-               case HAS_MINIMUM_SIGNED | EXCLUSIVE_MINIMUM:
-                  if( m_node->m_minimum.i >= 0 && v <= static_cast< std::uint64_t >( m_node->m_minimum.i ) ) {
-                     m_match = false;
-                  }
-                  break;
-               case HAS_MINIMUM_UNSIGNED:
-                  if( v < m_node->m_minimum.u ) {
-                     m_match = false;
-                  }
-                  break;
-               case HAS_MINIMUM_UNSIGNED | EXCLUSIVE_MINIMUM:
-                  if( v <= m_node->m_minimum.u ) {
-                     m_match = false;
-                  }
-                  break;
-               case HAS_MINIMUM_DOUBLE:
-                  if( v < m_node->m_minimum.d ) {
-                     m_match = false;
-                  }
-                  break;
-               case HAS_MINIMUM_DOUBLE | EXCLUSIVE_MINIMUM:
-                  if( v <= m_node->m_minimum.d ) {
-                     m_match = false;
-                  }
-                  break;
-            }
-         }
-         void validate_number( const double v )
-         {
-            validate_multiple_of( v );
-            switch( m_node->m_flags & ( HAS_MAXIMUM | EXCLUSIVE_MAXIMUM ) ) {
-               case HAS_MAXIMUM_SIGNED:
-                  if( v > m_node->m_maximum.i ) {
-                     m_match = false;
-                  }
-                  break;
-               case HAS_MAXIMUM_SIGNED | EXCLUSIVE_MAXIMUM:
-                  if( v >= m_node->m_maximum.i ) {
-                     m_match = false;
-                  }
-                  break;
-               case HAS_MAXIMUM_UNSIGNED:
-                  if( v > m_node->m_maximum.u ) {
-                     m_match = false;
-                  }
-                  break;
-               case HAS_MAXIMUM_UNSIGNED | EXCLUSIVE_MAXIMUM:
-                  if( v >= m_node->m_maximum.u ) {
-                     m_match = false;
-                  }
-                  break;
-               case HAS_MAXIMUM_DOUBLE:
-                  if( v > m_node->m_maximum.d ) {
-                     m_match = false;
-                  }
-                  break;
-               case HAS_MAXIMUM_DOUBLE | EXCLUSIVE_MAXIMUM:
-                  if( v >= m_node->m_maximum.d ) {
-                     m_match = false;
-                  }
-                  break;
-            }
-            switch( m_node->m_flags & ( HAS_MINIMUM | EXCLUSIVE_MINIMUM ) ) {
-               case HAS_MINIMUM_SIGNED:
-                  if( v < m_node->m_minimum.i ) {
-                     m_match = false;
-                  }
-                  break;
-               case HAS_MINIMUM_SIGNED | EXCLUSIVE_MINIMUM:
-                  if( v <= m_node->m_minimum.i ) {
-                     m_match = false;
-                  }
-                  break;
-               case HAS_MINIMUM_UNSIGNED:
-                  if( v < m_node->m_minimum.u ) {
-                     m_match = false;
-                  }
-                  break;
-               case HAS_MINIMUM_UNSIGNED | EXCLUSIVE_MINIMUM:
-                  if( v <= m_node->m_minimum.u ) {
-                     m_match = false;
-                  }
-                  break;
-               case HAS_MINIMUM_DOUBLE:
-                  if( v < m_node->m_minimum.d ) {
-                     m_match = false;
-                  }
-                  break;
-               case HAS_MINIMUM_DOUBLE | EXCLUSIVE_MINIMUM:
-                  if( v <= m_node->m_minimum.d ) {
-                     m_match = false;
-                  }
-                  break;
-            }
-         }
-         void validate_string( const std::string_view v )
-         {
-            if( ( m_node->m_flags & HAS_MAX_LENGTH ) && ( unicode_size( v ) > m_node->m_max_length ) ) {
-               m_match = false;
-            }
-            if( ( m_node->m_flags & HAS_MIN_LENGTH ) && ( unicode_size( v ) < m_node->m_min_length ) ) {
-               m_match = false;
-            }
-            if( m_match && m_node->m_pattern ) {
-               if( !std::regex_search( v.begin(), v.end(), *m_node->m_pattern ) ) {
-                  m_match = false;
-               }
-            }
-            if( m_match && m_node->m_format != schema_format::none ) {
-               switch( m_node->m_format ) {
-                  case schema_format::date_time:
-                     if( !internal::parse_date_time( v ) ) {
-                        m_match = false;
-                     }
-                     break;
-                  case schema_format::email:
-                     if( ( v.size() > 255 ) || !internal::parse< internal::email >( v ) ) {
-                        m_match = false;
-                     }
-                     break;
-                  case schema_format::hostname:
-                     if( ( v.size() > 255 ) || !internal::parse< internal::hostname >( v ) ) {
-                        m_match = false;
-                     }
-                     break;
-                  case schema_format::ipv4:
-                     if( !internal::parse< pegtl::uri::IPv4address >( v ) ) {
-                        m_match = false;
-                     }
-                     break;
-                  case schema_format::ipv6:
-                     if( !internal::parse< pegtl::uri::IPv6address >( v ) ) {
-                        m_match = false;
-                     }
-                     break;
-                  case schema_format::uri:
-                     // TODO: What rule exactly should we apply here?? JSON Schema is not exactly the best spec I've ever read...
-                     if( !internal::parse< pegtl::uri::URI >( v ) ) {
-                        m_match = false;
-                     }
-                     break;
-                  case schema_format::none:;
-               }
-            }
-         }
-         void validate_elements( const std::size_t v )
-         {
-            if( m_node->m_flags & HAS_MAX_ITEMS && v > m_node->m_max_items ) {
-               m_match = false;
-            }
-            if( m_node->m_flags & HAS_MIN_ITEMS && v < m_node->m_min_items ) {
-               m_match = false;
-            }
-         }
-         void validate_members( const std::size_t v )
-         {
-            if( m_node->m_flags & HAS_MAX_PROPERTIES && v > m_node->m_max_properties ) {
-               m_match = false;
-            }
-            if( m_node->m_flags & HAS_MIN_PROPERTIES && v < m_node->m_min_properties ) {
-               m_match = false;
-            }
-         }
-      public:
-         schema_consumer( const std::shared_ptr< const schema_container< Traits > >& c, const schema_node< Traits >& n )
-            : m_container( c ),
-              m_node( &n )
-         {
-            if( m_node->m_flags & HAS_ENUM ) {
-               const auto& a = m_node->m_value->at( "enum" ).get_array();
-               m_enum.reserve( a.size() );
-               for( const auto& e : a ) {
-                  m_enum.emplace_back( std::make_unique< events_compare< Traits > >() );
-                  m_enum.back()->push( &e );
-               }
-            }
-            if( const auto* p = m_node->m_all_of ) {
-               for( const auto& e : p->get_array() ) {
-                  m_all_of.push_back( m_container->consumer( &e.skip_value_ptr() ) );
-               }
-            }
-            if( const auto* p = m_node->m_any_of ) {
-               for( const auto& e : p->get_array() ) {
-                  m_any_of.push_back( m_container->consumer( &e.skip_value_ptr() ) );
-               }
-            }
-            if( const auto* p = m_node->m_one_of ) {
-               for( const auto& e : p->get_array() ) {
-                  m_one_of.push_back( m_container->consumer( &e.skip_value_ptr() ) );
-               }
-            }
-            if( const auto* p = m_node->m_not ) {
-               m_not = m_container->consumer( p );
-            }
-            for( const auto& e : m_node->m_schema_dependencies ) {
-               m_schema_dependencies.emplace( e.first, m_container->consumer( e.second ) );
-            }
-         }
-         schema_consumer( const schema_consumer& ) = delete;
-         schema_consumer( schema_consumer&& ) = delete;
-         ~schema_consumer() = default;
-         void operator=( const schema_consumer& ) = delete;
-         void operator=( schema_consumer&& ) = delete;
-         [[nodiscard]] bool finalize()
-         {
-            if( m_match && !m_all_of.empty() ) {
-               for( auto& e : m_all_of ) {
-                  if( !e->finalize() ) {
-                     m_match = false;
-                     break;
-                  }
-               }
-            }
-            if( m_match && !m_any_of.empty() ) {
-               m_any_of.erase( std::remove_if( m_any_of.begin(), m_any_of.end(), []( const std::unique_ptr< schema_consumer >& c ) { return !c->finalize(); } ), m_any_of.end() );
-               if( m_any_of.empty() ) {
-                  m_match = false;
-               }
-            }
-            if( m_match && !m_one_of.empty() ) {
-               m_one_of.erase( std::remove_if( m_one_of.begin(), m_one_of.end(), []( const std::unique_ptr< schema_consumer >& c ) { return !c->finalize(); } ), m_one_of.end() );
-               if( m_one_of.size() != 1 ) {
-                  m_match = false;
-               }
-            }
-            if( m_match && m_not && m_not->finalize() ) {
-               m_match = false;
-            }
-            if( m_match && m_node->m_flags & HAS_DEPENDENCIES ) {
-               for( const auto& e : m_node->m_schema_dependencies ) {
-                  if( m_keys.count( e.first ) != 0 ) {
-                     const auto it = m_schema_dependencies.find( e.first );
-                     if( it == m_schema_dependencies.end() ) {
-                        m_match = false;
-                        break;
-                     }
-                     if( !it->second->finalize() ) {
-                        m_match = false;
-                        break;
-                     }
-                  }
-               }
-            }
-            return m_match;
-         }
-         [[nodiscard]] bool match() const noexcept
-         {
-            return m_match;
-         }
-         void null()
-         {
-            if( m_match ) {
-               validate_type( NULL_ );
-            }
-            if( m_match ) {
-               validate_enum( []( events_compare< Traits >& c ) { c.null(); return ! c.match(); } );
-            }
-            if( m_match ) {
-               validate_collections( []( schema_consumer& c ) { c.null(); return ! c.match(); } );
-            }
-            if( m_match && m_hash ) {
-               m_hash->null();
-            }
-         }
-         void boolean( const bool v )
-         {
-            if( m_match ) {
-               validate_type( BOOLEAN );
-            }
-            if( m_match ) {
-               validate_enum( [ = ]( events_compare< Traits >& c ) { c.boolean( v ); return ! c.match(); } );
-            }
-            if( m_match ) {
-               validate_collections( [ = ]( schema_consumer& c ) { c.boolean( v ); return ! c.match(); } );
-            }
-            if( m_match && m_hash ) {
-               m_hash->boolean( v );
-            }
-         }
-         void number( const std::int64_t v )
-         {
-            if( m_match ) {
-               validate_type( INTEGER | NUMBER );
-            }
-            if( m_match ) {
-               validate_enum( [ = ]( events_compare< Traits >& c ) { c.number( v ); return ! c.match(); } );
-            }
-            if( m_match ) {
-               validate_collections( [ = ]( schema_consumer& c ) { c.number( v ); return ! c.match(); } );
-            }
-            if( m_match && m_count.empty() ) {
-               validate_number( v );
-            }
-            if( m_match && m_hash ) {
-               m_hash->number( v );
-            }
-         }
-         void number( const std::uint64_t v )
-         {
-            if( m_match ) {
-               validate_type( INTEGER | NUMBER );
-            }
-            if( m_match ) {
-               validate_enum( [ = ]( events_compare< Traits >& c ) { c.number( v ); return ! c.match(); } );
-            }
-            if( m_match ) {
-               validate_collections( [ = ]( schema_consumer& c ) { c.number( v ); return ! c.match(); } );
-            }
-            if( m_match && m_count.empty() ) {
-               validate_number( v );
-            }
-            if( m_match && m_hash ) {
-               m_hash->number( v );
-            }
-         }
-         void number( const double v )
-         {
-            if( m_match ) {
-               validate_type( NUMBER );
-            }
-            if( m_match ) {
-               validate_enum( [ = ]( events_compare< Traits >& c ) { c.number( v ); return ! c.match(); } );
-            }
-            if( m_match ) {
-               validate_collections( [ = ]( schema_consumer& c ) { c.number( v ); return ! c.match(); } );
-            }
-            if( m_match && m_count.empty() ) {
-               validate_number( v );
-            }
-            if( m_match && m_hash ) {
-               m_hash->number( v );
-            }
-         }
-         void string( const std::string_view v )
-         {
-            if( m_match ) {
-               validate_type( STRING );
-            }
-            if( m_match ) {
-               validate_enum( [ & ]( events_compare< Traits >& c ) { c.string( v ); return ! c.match(); } );
-            }
-            if( m_match ) {
-               validate_collections( [ & ]( schema_consumer& c ) { c.string( v ); return ! c.match(); } );
-            }
-            if( m_match && m_count.empty() ) {
-               validate_string( v );
-            }
-            if( m_match && m_hash ) {
-               m_hash->string( v );
-            }
-         }
-         void binary( const tao::binary_view /*unused*/ )
-         {
-            // TODO: What?
-         }
-         void begin_array( const std::size_t /*unused*/ = 0 )
-         {
-            if( m_match ) {
-               validate_type( ARRAY );
-            }
-            if( m_match ) {
-               validate_enum( []( events_compare< Traits >& c ) { c.begin_array(); return ! c.match(); } );
-            }
-            if( m_match ) {
-               validate_collections( []( schema_consumer& c ) { c.begin_array(); return ! c.match(); } );
-            }
-            if( m_match ) {
-               if( m_hash ) {
-                  m_hash->begin_array();
-               }
-               else if( m_count.empty() && ( ( m_node->m_flags & HAS_UNIQUE_ITEMS ) != 0 ) ) {
-                  m_hash = std::make_unique< events::hash >();
-               }
-            }
-            if( m_match && m_count.empty() ) {
-               if( const auto* p = m_node->m_items ) {
-                  if( p->is_object() ) {
-                     m_item = m_container->consumer( p );
-                  }
-                  else {
-                     const auto& a = p->get_array();
-                     if( !a.empty() ) {
-                        m_item = m_container->consumer( &a[ 0 ].skip_value_ptr() );
-                     }
-                  }
-               }
-               if( !m_item ) {
-                  if( const auto* p = m_node->m_additional_items ) {
-                     if( p->is_object() ) {
-                        m_item = m_container->consumer( p );
-                     }
-                  }
-               }
-            }
-            m_count.push_back( 0 );
-         }
-         void element()
-         {
-            if( m_match ) {
-               validate_enum( []( events_compare< Traits >& c ) { c.element(); return ! c.match(); } );
-            }
-            if( m_match && m_item ) {
-               if( m_count.size() == 1 ) {
-                  if( !m_item->finalize() ) {
-                     m_match = false;
-                  }
-                  m_item.reset();
-               }
-            }
-            if( m_match ) {
-               validate_collections( []( schema_consumer& c ) { c.element(); return ! c.match(); } );
-            }
-            if( m_match && m_hash ) {
-               if( m_count.size() == 1 ) {
-                  if( !m_unique.emplace( m_hash->value() ).second ) {
-                     m_match = false;
-                  }
-                  m_hash->reset();
-               }
-               else {
-                  m_hash->element();
-               }
-            }
-            const auto next = ++m_count.back();
-            if( m_match && ( m_count.size() == 1 ) ) {
-               if( const auto* p = m_node->m_items ) {
-                  if( p->is_object() ) {
-                     m_item = m_container->consumer( p );
-                  }
-                  else {
-                     const auto& a = p->get_array();
-                     if( next < a.size() ) {
-                        m_item = m_container->consumer( &a[ next ].skip_value_ptr() );
-                     }
-                  }
-               }
-               if( !m_item ) {
-                  if( const auto* p = m_node->m_additional_items ) {
-                     if( p->is_object() ) {
-                        m_item = m_container->consumer( p );
-                     }
-                  }
-               }
-            }
-         }
-         void end_array( const std::size_t /*unused*/ = 0 )
-         {
-            if( m_match ) {
-               validate_enum( []( events_compare< Traits >& c ) { c.end_array(); return ! c.match(); } );
-            }
-            if( m_match && m_item && ( m_count.size() == 1 ) ) {
-               if( !m_item->finalize() ) {
-                  m_match = false;
-               }
-               m_item.reset();
-            }
-            if( m_match && ( m_count.size() == 1 ) ) {
-               if( m_node->m_items && m_node->m_items->is_array() ) {
-                  if( m_node->m_additional_items && m_node->m_additional_items->is_boolean() ) {
-                     if( !m_node->m_additional_items->get_boolean() ) {
-                        if( m_count.back() > m_node->m_items->get_array().size() ) {
-                           m_match = false;
-                        }
-                     }
-                  }
-               }
-            }
-            if( m_match ) {
-               validate_collections( []( schema_consumer& c ) { c.end_array(); return ! c.match(); } );
-            }
-            if( m_match && m_hash ) {
-               m_hash->end_array();
-            }
-            if( m_match && ( m_count.size() == 1 ) ) {
-               validate_elements( m_count.back() );
-            }
-            m_count.pop_back();
-         }
-         void begin_object( const std::size_t /*unused*/ = 0 )
-         {
-            if( m_match ) {
-               validate_type( OBJECT );
-            }
-            if( m_match ) {
-               validate_enum( []( events_compare< Traits >& c ) { c.begin_object(); return ! c.match(); } );
-            }
-            if( m_match ) {
-               validate_collections( []( schema_consumer& c ) { c.begin_object(); return ! c.match(); } );
-            }
-            if( m_match && m_hash ) {
-               m_hash->begin_object();
-            }
-            m_count.push_back( 0 );
-         }
-         void key( const std::string_view sv )
-         {
-            if( m_match ) {
-               validate_enum( [ & ]( events_compare< Traits >& c ) { c.key( sv ); return ! c.match(); } );
-            }
-            if( m_match ) {
-               validate_collections( [ & ]( schema_consumer& c ) { c.key( sv ); return ! c.match(); } );
-            }
-            if( m_match && m_hash ) {
-               m_hash->key( sv );
-            }
-            if( m_match && ( m_count.size() == 1 ) && ( m_node->m_flags & HAS_DEPENDENCIES || !m_node->m_required.empty() ) ) {
-               if( !m_keys.insert( std::string( sv ) ).second ) {
-                  // duplicate keys immediately invalidate!
-                  // TODO: throw?
-                  m_match = false;
-               }
-            }
-            if( m_match && m_properties.empty() && ( m_count.size() == 1 ) ) {
-               if( const auto* p = m_node->m_properties ) {
-                  const auto& o = p->get_object();
-                  const auto it = o.find( sv );
-                  if( it != o.end() ) {
-                     m_properties.push_back( m_container->consumer( &it->second.skip_value_ptr() ) );
-                  }
-               }
-               for( const auto& e : m_node->m_pattern_properties ) {
-                  if( std::regex_search( sv.begin(), sv.end(), e.first ) ) {
-                     m_properties.push_back( m_container->consumer( e.second ) );
-                  }
-               }
-               if( m_properties.empty() ) {
-                  if( const auto* p = m_node->m_additional_properties ) {
-                     if( p->is_boolean() ) {
-                        if( !p->get_boolean() ) {
-                           m_match = false;
-                        }
-                     }
-                     else {
-                        m_properties.push_back( m_container->consumer( p ) );
-                     }
-                  }
-               }
-            }
-         }
-         void member()
-         {
-            if( m_match ) {
-               validate_enum( []( events_compare< Traits >& c ) { c.member(); return ! c.match(); } );
-            }
-            if( m_match && !m_properties.empty() && ( m_count.size() == 1 ) ) {
-               for( auto& e : m_properties ) {
-                  if( !e->finalize() ) {
-                     m_match = false;
-                     break;
-                  }
-               }
-               m_properties.clear();
-            }
-            if( m_match ) {
-               validate_collections( []( schema_consumer& c ) { c.member(); return ! c.match(); } );
-            }
-            if( m_match && m_hash ) {
-               m_hash->member();
-            }
-            ++m_count.back();
-         }
-         void end_object( const std::size_t /*unused*/ = 0 )
-         {
-            if( m_match ) {
-               validate_enum( []( events_compare< Traits >& c ) { c.end_object(); return ! c.match(); } );
-            }
-            if( m_match ) {
-               validate_collections( []( schema_consumer& c ) { c.end_object(); return ! c.match(); } );
-            }
-            if( m_match && m_hash ) {
-               m_hash->end_object();
-            }
-            if( m_match && ( m_count.size() == 1 ) ) {
-               validate_members( m_count.back() );
-            }
-            if( m_match && ( m_count.size() == 1 ) && !m_node->m_required.empty() ) {
-               if( !std::includes( m_keys.begin(), m_keys.end(), m_node->m_required.begin(), m_node->m_required.end() ) ) {
-                  m_match = false;
-               }
-            }
-            if( m_match && ( m_count.size() == 1 ) && m_node->m_flags & HAS_DEPENDENCIES ) {
-               for( const auto& e : m_node->m_property_dependencies ) {
-                  if( m_keys.count( e.first ) != 0 ) {
-                     if( !std::includes( m_keys.begin(), m_keys.end(), e.second.begin(), e.second.end() ) ) {
-                        m_match = false;
-                        break;
-                     }
-                  }
-               }
-            }
-            m_count.pop_back();
-         }
-      };
-      template< template< typename... > class Traits >
-      class schema_container
-         : public std::enable_shared_from_this< schema_container< Traits > >
-      {
-      private:
-         basic_value< Traits > m_value;
-         using nodes_t = std::map< const basic_value< Traits >*, std::unique_ptr< schema_node< Traits > > >;
-         nodes_t m_nodes;
-         void make_node( const basic_value< Traits >* p )
-         {
-            m_nodes.emplace( p, std::make_unique< schema_node< Traits > >( this, *p ) );
-         }
-      public:
-         explicit schema_container( const basic_value< Traits >& v )
-            : m_value( v.skip_value_ptr() )
-         {
-            resolve_references( m_value );
-            make_node( &m_value );
-            while( true ) {
-               std::set< const basic_value< Traits >* > required;
-               for( const auto& e : m_nodes ) {
-                  auto s = e.second->referenced_pointers();
-                  required.insert( s.begin(), s.end() );
-               }
-               for( const auto& e : m_nodes ) {
-                  required.erase( e.first );
-               }
-               if( required.empty() ) {
-                  break;
-               }
-               for( const auto& e : required ) {
-                  make_node( e );
-               }
-            }
-         }
-         [[nodiscard]] std::unique_ptr< schema_consumer< Traits > > consumer( const basic_value< Traits >* p ) const
-         {
-            const auto it = m_nodes.find( p );
-            if( it == m_nodes.end() ) {
-               throw std::logic_error( "invalid node ptr, no schema registered" );
-            }
-            return std::make_unique< schema_consumer< Traits > >( this->shared_from_this(), *it->second );
-         }
-         [[nodiscard]] std::unique_ptr< schema_consumer< Traits > > consumer() const
-         {
-            return consumer( &m_value );
-         }
-      };
-   }  // namespace internal
-   template< template< typename... > class Traits >
-   class basic_schema
-   {
-   private:
-      const std::shared_ptr< const internal::schema_container< Traits > > m_container;
-   public:
-      explicit basic_schema( const basic_value< Traits >& v )
-         : m_container( std::make_shared< internal::schema_container< Traits > >( v ) )
-      {
-      }
-      [[nodiscard]] std::unique_ptr< internal::schema_consumer< Traits > > consumer() const
-      {
-         return m_container->consumer();
-      }
-      [[nodiscard]] bool validate( const basic_value< Traits >& v ) const
-      {
-         // TODO: Value validation should be implemented independently,
-         // as it could be more efficient than Events validation!
-         const auto c = consumer();
-         events::from_value( *c, v );
-         return c->finalize();
-      }
-   };
-   using schema = basic_schema< traits >;
-   template< template< typename... > class Traits >
-   [[nodiscard]] basic_schema< Traits > make_schema( const basic_value< Traits >& v )
-   {
-      return basic_schema< Traits >( v );
-   }
-}  // namespace tao::json
-#endif