jsonbinpack/src/compiler/compiler.cc at 74d0f0052e7044ccd59a76d3c33afd6fa7773b32 · sourcemeta/jsonbinpack · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
#include <sourcemeta/jsonbinpack/compiler.h>

#include <sourcemeta/core/numeric.h>

#include <sourcemeta/blaze/alterschema.h>
#include <sourcemeta/blaze/canonicalizer.h>
#include <sourcemeta/core/jsonpointer.h>

#include "encoding.h"

#include <cassert>     // assert
#include <type_traits> // std::true_type

static auto transformer_callback_noop(
    const sourcemeta::core::Pointer &, const std::string_view,
    const std::string_view,
    const sourcemeta::blaze::SchemaTransformRule::Result &,
    [[maybe_unused]] const bool applied) -> void {
  assert(applied);
}

namespace sourcemeta::jsonbinpack {

auto canonicalize(sourcemeta::core::JSON &schema,
                  const sourcemeta::blaze::SchemaWalker &walker,
                  const sourcemeta::blaze::SchemaResolver &resolver,
                  const std::string_view default_dialect) -> void {
  sourcemeta::blaze::canonicalize(schema, walker, make_resolver(resolver),
                                  default_dialect);
}

auto make_encoding(sourcemeta::core::JSON &document,
                   const std::string &encoding,
                   const sourcemeta::core::JSON &options) -> void {
  document.into_object();
  document.assign("$schema", sourcemeta::core::JSON{ENCODING_V1});
  document.assign("binpackEncoding", sourcemeta::core::JSON{encoding});
  document.assign("binpackOptions", options);
}

#include "mapper/enum_8_bit.h"
#include "mapper/enum_8_bit_top_level.h"
#include "mapper/enum_arbitrary.h"
#include "mapper/enum_singleton.h"
#include "mapper/integer_bounded_8_bit.h"
#include "mapper/integer_bounded_greater_than_8_bit.h"
#include "mapper/integer_bounded_multiplier_8_bit.h"
#include "mapper/integer_bounded_multiplier_greater_than_8_bit.h"
#include "mapper/integer_lower_bound.h"
#include "mapper/integer_lower_bound_multiplier.h"
#include "mapper/integer_unbound.h"
#include "mapper/integer_unbound_multiplier.h"
#include "mapper/integer_upper_bound.h"
#include "mapper/integer_upper_bound_multiplier.h"
#include "mapper/number_arbitrary.h"

auto compile(sourcemeta::core::JSON &schema,
             const sourcemeta::blaze::SchemaWalker &walker,
             const sourcemeta::blaze::SchemaResolver &resolver,
             const std::string_view default_dialect) -> void {
  sourcemeta::jsonbinpack::canonicalize(schema, walker, resolver,
                                        default_dialect);

  sourcemeta::blaze::SchemaTransformer mapper;

  // Enums
  mapper.add<Enum8Bit>();
  mapper.add<Enum8BitTopLevel>();
  mapper.add<EnumArbitrary>();
  mapper.add<EnumSingleton>();

  // Integers
  mapper.add<IntegerBounded8Bit>();
  mapper.add<IntegerBoundedMultiplier8Bit>();
  mapper.add<IntegerBoundedGreaterThan8Bit>();
  mapper.add<IntegerBoundedMultiplierGreaterThan8Bit>();
  mapper.add<IntegerLowerBound>();
  mapper.add<IntegerLowerBoundMultiplier>();
  mapper.add<IntegerUpperBound>();
  mapper.add<IntegerUpperBoundMultiplier>();
  mapper.add<IntegerUnbound>();
  mapper.add<IntegerUnboundMultiplier>();

  // Numbers
  mapper.add<NumberArbitrary>();

  [[maybe_unused]] const auto mapper_result =
      mapper.apply(schema, walker, make_resolver(resolver),
                   transformer_callback_noop, default_dialect);
  assert(mapper_result.first);

  // The "any" encoding is always the last resort
  const auto dialect{sourcemeta::blaze::dialect(schema)};
  if (dialect.empty() || dialect != ENCODING_V1) {
    make_encoding(schema, "ANY_PACKED_TYPE_TAG_BYTE_PREFIX",
                  sourcemeta::core::JSON::make_object());
  }
}

} // namespace sourcemeta::jsonbinpack