binpack_encoding.h

#ifndef SOURCEMETA_BLAZE_BINPACK_ENCODING_H_
#define SOURCEMETA_BLAZE_BINPACK_ENCODING_H_
 
#include <sourcemeta/core/json.h>
#include <sourcemeta/core/numeric.h>
 
#include <cstdint> // std::int64_t, std::uint64_t
#include <memory>  // std::shared_ptr
#include <variant> // std::variant
#include <vector>  // std::vector
 
namespace sourcemeta::blaze {
 
// Forward declarations for the sole purpose of being bale to define circular
// structures
#ifndef DOXYGEN
// The encoding names are the ones the JSON BinPack specification
// defines, so they keep their casing rather than following the C++
// naming convention
// NOLINTBEGIN(readability-identifier-naming)
struct BOUNDED_MULTIPLE_8BITS_ENUM_FIXED;
struct FLOOR_MULTIPLE_ENUM_VARINT;
struct ROOF_MULTIPLE_MIRROR_ENUM_VARINT;
struct ARBITRARY_MULTIPLE_ZIGZAG_VARINT;
struct DOUBLE_VARINT_TUPLE;
struct NUMBER_VARINT_TUPLE;
struct BYTE_CHOICE_INDEX;
struct LARGE_CHOICE_INDEX;
struct TOP_LEVEL_BYTE_CHOICE_INDEX;
struct CONST_NONE;
struct ANY_PACKED_TYPE_TAG_BYTE_PREFIX;
struct UTF8_STRING_NO_LENGTH;
struct FLOOR_VARINT_PREFIX_UTF8_STRING_SHARED;
struct ROOF_VARINT_PREFIX_UTF8_STRING_SHARED;
struct BOUNDED_8BIT_PREFIX_UTF8_STRING_SHARED;
struct RFC3339_DATE_INTEGER_TRIPLET;
struct PREFIX_VARINT_LENGTH_STRING_SHARED;
struct FIXED_TYPED_ARRAY;
struct BOUNDED_8BITS_TYPED_ARRAY;
struct FLOOR_TYPED_ARRAY;
struct ROOF_TYPED_ARRAY;
struct FIXED_TYPED_ARBITRARY_OBJECT;
struct VARINT_TYPED_ARBITRARY_OBJECT;
// NOLINTEND(readability-identifier-naming)
#endif

using BinPackEncoding = 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, ANY_PACKED_TYPE_TAG_BYTE_PREFIX,
    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,
    NUMBER_VARINT_TUPLE>;
 
// The encoding names are the ones the JSON BinPack specification
// defines, so they keep their casing rather than following the C++
// naming convention
// NOLINTBEGIN(readability-identifier-naming)

 
// clang-format off
// clang-format on
struct BOUNDED_MULTIPLE_8BITS_ENUM_FIXED {
  std::int64_t minimum;
  std::int64_t maximum;
  std::uint64_t multiplier;
};
 
// clang-format off
// clang-format on
struct FLOOR_MULTIPLE_ENUM_VARINT {
  std::int64_t minimum;
  std::uint64_t multiplier;
};
 
// clang-format off
// clang-format on
struct ROOF_MULTIPLE_MIRROR_ENUM_VARINT {
  std::int64_t maximum;
  std::uint64_t multiplier;
};
 
// clang-format off
// clang-format on
struct ARBITRARY_MULTIPLE_ZIGZAG_VARINT {
  std::uint64_t multiplier;
};


 
// clang-format off
// clang-format on
struct DOUBLE_VARINT_TUPLE {};
 
// clang-format off
// clang-format on
struct NUMBER_VARINT_TUPLE {};


 
// clang-format off
// clang-format on
struct BYTE_CHOICE_INDEX {
  std::vector<sourcemeta::core::JSON> choices;
};
 
// clang-format off
// clang-format on
struct LARGE_CHOICE_INDEX {
  std::vector<sourcemeta::core::JSON> choices;
};
 
// clang-format off
// clang-format on
struct TOP_LEVEL_BYTE_CHOICE_INDEX {
  std::vector<sourcemeta::core::JSON> choices;
};
 
// clang-format off
// clang-format on
struct CONST_NONE {
  sourcemeta::core::JSON value;
};
 
// TODO: Write brief description
struct ANY_PACKED_TYPE_TAG_BYTE_PREFIX {};
#ifndef DOXYGEN
namespace 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 <= sourcemeta::core::uint_max<TYPE_SIZE>);
static_assert(TYPE_STRING <= sourcemeta::core::uint_max<TYPE_SIZE>);
static_assert(TYPE_LONG_STRING <= sourcemeta::core::uint_max<TYPE_SIZE>);
static_assert(TYPE_OBJECT <= sourcemeta::core::uint_max<TYPE_SIZE>);
static_assert(TYPE_ARRAY <= sourcemeta::core::uint_max<TYPE_SIZE>);
static_assert(TYPE_POSITIVE_INTEGER_BYTE <=
              sourcemeta::core::uint_max<TYPE_SIZE>);
static_assert(TYPE_NEGATIVE_INTEGER_BYTE <=
              sourcemeta::core::uint_max<TYPE_SIZE>);
static_assert(TYPE_OTHER <= sourcemeta::core::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_POSITIVE_REAL_INTEGER_BYTE = 0b00000110;
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;
constexpr std::uint8_t SUBTYPE_DECIMAL = 0b00001011;
 
static_assert(SUBTYPE_FALSE <= sourcemeta::core::uint_max<SUBTYPE_SIZE>);
static_assert(SUBTYPE_TRUE <= sourcemeta::core::uint_max<SUBTYPE_SIZE>);
static_assert(SUBTYPE_NULL <= sourcemeta::core::uint_max<SUBTYPE_SIZE>);
static_assert(SUBTYPE_POSITIVE_INTEGER <=
              sourcemeta::core::uint_max<SUBTYPE_SIZE>);
static_assert(SUBTYPE_NEGATIVE_INTEGER <=
              sourcemeta::core::uint_max<SUBTYPE_SIZE>);
static_assert(SUBTYPE_NUMBER <= sourcemeta::core::uint_max<SUBTYPE_SIZE>);
static_assert(SUBTYPE_POSITIVE_REAL_INTEGER_BYTE <=
              sourcemeta::core::uint_max<SUBTYPE_SIZE>);
static_assert(SUBTYPE_LONG_STRING_BASE_EXPONENT_7 <=
              sourcemeta::core::uint_max<SUBTYPE_SIZE>);
static_assert(SUBTYPE_LONG_STRING_BASE_EXPONENT_8 <=
              sourcemeta::core::uint_max<SUBTYPE_SIZE>);
static_assert(SUBTYPE_LONG_STRING_BASE_EXPONENT_9 <=
              sourcemeta::core::uint_max<SUBTYPE_SIZE>);
static_assert(SUBTYPE_LONG_STRING_BASE_EXPONENT_10 <=
              sourcemeta::core::uint_max<SUBTYPE_SIZE>);
static_assert(SUBTYPE_DECIMAL <= sourcemeta::core::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 any_packed_type_tag_byte_prefix
#endif


 
// clang-format off
// clang-format on
struct UTF8_STRING_NO_LENGTH {
  std::uint64_t size;
};
 
// clang-format off
// clang-format on
struct FLOOR_VARINT_PREFIX_UTF8_STRING_SHARED {
  std::uint64_t minimum;
};
 
// clang-format off
// clang-format on
struct ROOF_VARINT_PREFIX_UTF8_STRING_SHARED {
  std::uint64_t maximum;
};
 
// clang-format off
// clang-format on
struct BOUNDED_8BIT_PREFIX_UTF8_STRING_SHARED {
  std::uint64_t minimum;
  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 {
  std::uint64_t size;
  std::shared_ptr<BinPackEncoding> encoding;
  std::vector<BinPackEncoding> prefix_encodings;
};
 
// clang-format off
// clang-format on
struct BOUNDED_8BITS_TYPED_ARRAY {
  std::uint64_t minimum;
  std::uint64_t maximum;
  std::shared_ptr<BinPackEncoding> encoding;
  std::vector<BinPackEncoding> prefix_encodings;
};
 
// clang-format off
// clang-format on
struct FLOOR_TYPED_ARRAY {
  std::uint64_t minimum;
  std::shared_ptr<BinPackEncoding> encoding;
  std::vector<BinPackEncoding> prefix_encodings;
};
 
// clang-format off
// clang-format on
struct ROOF_TYPED_ARRAY {
  std::uint64_t maximum;
  std::shared_ptr<BinPackEncoding> encoding;
  std::vector<BinPackEncoding> prefix_encodings;
};


 
// clang-format off
// clang-format on
struct FIXED_TYPED_ARBITRARY_OBJECT {
  std::uint64_t size;
  std::shared_ptr<BinPackEncoding> key_encoding;
  std::shared_ptr<BinPackEncoding> encoding;
};
 
// clang-format off
// clang-format on
struct VARINT_TYPED_ARBITRARY_OBJECT {
  std::shared_ptr<BinPackEncoding> key_encoding;
  std::shared_ptr<BinPackEncoding> encoding;
};

 
// NOLINTEND(readability-identifier-naming)
 
} // namespace sourcemeta::blaze
 
#endif