runtime_plan.h

#ifndef SOURCEMETA_JSONBINPACK_RUNTIME_ENCODING_H_
#define SOURCEMETA_JSONBINPACK_RUNTIME_ENCODING_H_
 
#include <sourcemeta/jsonbinpack/runtime_numeric.h>
#include <sourcemeta/jsontoolkit/json.h>
 
#include <cstdint> // std::int64_t, std::uint64_t
#include <memory>  // std::shared_ptr
#include <variant> // std::variant
#include <vector>  // std::vector
 
namespace sourcemeta::jsonbinpack {
 
// We cannot directly create an Plan variant type whose values potentially
// include other Plan instances.  As a workaround, we have a helper
// encoding wrapper that we can use as an incomplete type
struct __internal_encoding_wrapper;
// Use these alias types. Never use the internal wrapper type directly
using SinglePlan = std::shared_ptr<__internal_encoding_wrapper>;
using MultiplePlans = std::vector<__internal_encoding_wrapper>;
 
 
// clang-format off
// clang-format on
struct BOUNDED_MULTIPLE_8BITS_ENUM_FIXED {
  const std::int64_t minimum;
  const std::int64_t maximum;
  const std::uint64_t multiplier;
};
 
// clang-format off
// clang-format on
struct FLOOR_MULTIPLE_ENUM_VARINT {
  const std::int64_t minimum;
  const std::uint64_t multiplier;
};
 
// clang-format off
// clang-format on
struct ROOF_MULTIPLE_MIRROR_ENUM_VARINT {
  const std::int64_t maximum;
  const std::uint64_t multiplier;
};
 
// clang-format off
// clang-format on
struct ARBITRARY_MULTIPLE_ZIGZAG_VARINT {
  const std::uint64_t multiplier;
};
 
 
 
// clang-format off
// clang-format on
struct DOUBLE_VARINT_TUPLE {};
 
 
 
// clang-format off
// clang-format on
struct BYTE_CHOICE_INDEX {
  const std::vector<sourcemeta::jsontoolkit::JSON> choices;
};
 
// clang-format off
// clang-format on
struct LARGE_CHOICE_INDEX {
  const std::vector<sourcemeta::jsontoolkit::JSON> choices;
};
 
// clang-format off
// clang-format on
struct TOP_LEVEL_BYTE_CHOICE_INDEX {
  const std::vector<sourcemeta::jsontoolkit::JSON> choices;
};
 
// clang-format off
// clang-format on
struct CONST_NONE {
  const sourcemeta::jsontoolkit::JSON value;
};
 
 
 
// clang-format off
// clang-format on
struct UTF8_STRING_NO_LENGTH {
  const std::uint64_t size;
};
 
// clang-format off
// clang-format on
struct FLOOR_VARINT_PREFIX_UTF8_STRING_SHARED {
  const std::uint64_t minimum;
};
 
// clang-format off
// clang-format on
struct ROOF_VARINT_PREFIX_UTF8_STRING_SHARED {
  const std::uint64_t maximum;
};
 
// clang-format off
// clang-format on
struct BOUNDED_8BIT_PREFIX_UTF8_STRING_SHARED {
  const std::uint64_t minimum;
  const std::uint64_t maximum;
};
 
// clang-format off
// clang-format on
struct RFC3339_DATE_INTEGER_TRIPLET {};
 
// clang-format off
// clang-format on
struct PREFIX_VARINT_LENGTH_STRING_SHARED {};
 
 
 
// clang-format off
// clang-format on
struct FIXED_TYPED_ARRAY {
  const std::uint64_t size;
  const SinglePlan encoding;
  const MultiplePlans prefix_encodings;
};
 
// clang-format off
// clang-format on
struct BOUNDED_8BITS_TYPED_ARRAY {
  const std::uint64_t minimum;
  const std::uint64_t maximum;
  const SinglePlan encoding;
  const MultiplePlans prefix_encodings;
};
 
// clang-format off
// clang-format on
struct FLOOR_TYPED_ARRAY {
  const std::uint64_t minimum;
  const SinglePlan encoding;
  const MultiplePlans prefix_encodings;
};
 
// clang-format off
// clang-format on
struct ROOF_TYPED_ARRAY {
  const std::uint64_t maximum;
  const SinglePlan encoding;
  const MultiplePlans prefix_encodings;
};
 
 
 
// clang-format off
// clang-format on
struct FIXED_TYPED_ARBITRARY_OBJECT {
  const std::uint64_t size;
  const SinglePlan key_encoding;
  const SinglePlan encoding;
};
 
// clang-format off
// clang-format on
struct VARINT_TYPED_ARBITRARY_OBJECT {
  const SinglePlan key_encoding;
  const SinglePlan encoding;
};
 
 
 
// TODO: Write brief description
struct ANY_PACKED_TYPE_TAG_BYTE_PREFIX {};
#ifndef DOXYGEN
namespace internal::ANY_PACKED_TYPE_TAG_BYTE_PREFIX {
constexpr auto type_size = 3;
constexpr std::uint8_t TYPE_SHARED_STRING = 0b00000000;
constexpr std::uint8_t TYPE_STRING = 0b00000001;
constexpr std::uint8_t TYPE_LONG_STRING = 0b00000010;
constexpr std::uint8_t TYPE_OBJECT = 0b00000011;
constexpr std::uint8_t TYPE_ARRAY = 0b00000100;
constexpr std::uint8_t TYPE_POSITIVE_INTEGER_BYTE = 0b00000101;
constexpr std::uint8_t TYPE_NEGATIVE_INTEGER_BYTE = 0b00000110;
constexpr std::uint8_t TYPE_OTHER = 0b00000111;
static_assert(TYPE_SHARED_STRING <= uint_max<type_size>);
static_assert(TYPE_STRING <= uint_max<type_size>);
static_assert(TYPE_LONG_STRING <= uint_max<type_size>);
static_assert(TYPE_OBJECT <= uint_max<type_size>);
static_assert(TYPE_ARRAY <= uint_max<type_size>);
static_assert(TYPE_POSITIVE_INTEGER_BYTE <= uint_max<type_size>);
static_assert(TYPE_NEGATIVE_INTEGER_BYTE <= uint_max<type_size>);
static_assert(TYPE_OTHER <= uint_max<type_size>);
 
constexpr auto subtype_size = 5;
constexpr std::uint8_t SUBTYPE_FALSE = 0b00000000;
constexpr std::uint8_t SUBTYPE_TRUE = 0b00000001;
constexpr std::uint8_t SUBTYPE_NULL = 0b00000010;
constexpr std::uint8_t SUBTYPE_POSITIVE_INTEGER = 0b00000011;
constexpr std::uint8_t SUBTYPE_NEGATIVE_INTEGER = 0b00000100;
constexpr std::uint8_t SUBTYPE_NUMBER = 0b00000101;
constexpr std::uint8_t SUBTYPE_LONG_STRING_BASE_EXPONENT_7 = 0b00000111;
constexpr std::uint8_t SUBTYPE_LONG_STRING_BASE_EXPONENT_8 = 0b00001000;
constexpr std::uint8_t SUBTYPE_LONG_STRING_BASE_EXPONENT_9 = 0b00001001;
constexpr std::uint8_t SUBTYPE_LONG_STRING_BASE_EXPONENT_10 = 0b00001010;
 
static_assert(SUBTYPE_FALSE <= uint_max<subtype_size>);
static_assert(SUBTYPE_TRUE <= uint_max<subtype_size>);
static_assert(SUBTYPE_NULL <= uint_max<subtype_size>);
static_assert(SUBTYPE_POSITIVE_INTEGER <= uint_max<subtype_size>);
static_assert(SUBTYPE_NEGATIVE_INTEGER <= uint_max<subtype_size>);
static_assert(SUBTYPE_NUMBER <= uint_max<subtype_size>);
static_assert(SUBTYPE_LONG_STRING_BASE_EXPONENT_7 <= uint_max<subtype_size>);
static_assert(SUBTYPE_LONG_STRING_BASE_EXPONENT_8 <= uint_max<subtype_size>);
static_assert(SUBTYPE_LONG_STRING_BASE_EXPONENT_9 <= uint_max<subtype_size>);
static_assert(SUBTYPE_LONG_STRING_BASE_EXPONENT_10 <= uint_max<subtype_size>);
 
// Note that the binary values actually match the declared exponents
static_assert(SUBTYPE_LONG_STRING_BASE_EXPONENT_7 == 7);
static_assert(SUBTYPE_LONG_STRING_BASE_EXPONENT_8 == 8);
static_assert(SUBTYPE_LONG_STRING_BASE_EXPONENT_9 == 9);
static_assert(SUBTYPE_LONG_STRING_BASE_EXPONENT_10 == 10);
} // namespace internal::ANY_PACKED_TYPE_TAG_BYTE_PREFIX
#endif
 
// clang-format on
 
using Plan = std::variant<
    BOUNDED_MULTIPLE_8BITS_ENUM_FIXED, FLOOR_MULTIPLE_ENUM_VARINT,
    ROOF_MULTIPLE_MIRROR_ENUM_VARINT, ARBITRARY_MULTIPLE_ZIGZAG_VARINT,
    DOUBLE_VARINT_TUPLE, BYTE_CHOICE_INDEX, LARGE_CHOICE_INDEX,
    TOP_LEVEL_BYTE_CHOICE_INDEX, CONST_NONE, UTF8_STRING_NO_LENGTH,
    FLOOR_VARINT_PREFIX_UTF8_STRING_SHARED,
    ROOF_VARINT_PREFIX_UTF8_STRING_SHARED,
    BOUNDED_8BIT_PREFIX_UTF8_STRING_SHARED, RFC3339_DATE_INTEGER_TRIPLET,
    PREFIX_VARINT_LENGTH_STRING_SHARED, FIXED_TYPED_ARRAY,
    BOUNDED_8BITS_TYPED_ARRAY, FLOOR_TYPED_ARRAY, ROOF_TYPED_ARRAY,
    FIXED_TYPED_ARBITRARY_OBJECT, VARINT_TYPED_ARBITRARY_OBJECT,
    ANY_PACKED_TYPE_TAG_BYTE_PREFIX>;
 
// Helper definitions that rely on the Plan data type
#ifndef DOXYGEN
// Ignore this definition on the documentation
struct __internal_encoding_wrapper {
  const Plan value;
};
#endif
 
} // namespace sourcemeta::jsonbinpack
 
#endif