jsonbinpack/src/runtime/loader_v1_array.h at 15efbf1b1e098e8e8bf4a44446bedf7c6440c927 · 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
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
#ifndef SOURCEMETA_JSONBINPACK_RUNTIME_LOADER_V1_ARRAY_H_
#define SOURCEMETA_JSONBINPACK_RUNTIME_LOADER_V1_ARRAY_H_

#include <sourcemeta/jsonbinpack/runtime.h>

#include <sourcemeta/core/json.h>

#include <algorithm> // std::transform
#include <cassert>   // assert
#include <cstdint>   // std::uint64_t
#include <iterator>  // std::back_inserter
#include <memory>    // std::make_shared
#include <vector>    // std::vector

namespace sourcemeta::jsonbinpack::v1 {

auto FIXED_TYPED_ARRAY(const sourcemeta::core::JSON &options) -> Encoding {
  assert(options.defines("size"));
  assert(options.defines("encoding"));
  assert(options.defines("prefixEncodings"));
  const auto &size{options.at("size")};
  const auto &array_encoding{options.at("encoding")};
  const auto &prefix_encodings{options.at("prefixEncodings")};
  assert(size.is_integer());
  assert(size.is_positive());
  assert(array_encoding.is_object());
  assert(prefix_encodings.is_array());
  std::vector<Encoding> encodings;
  std::transform(prefix_encodings.as_array().cbegin(),
                 prefix_encodings.as_array().cend(),
                 std::back_inserter(encodings),
                 [](const auto &element) -> Encoding { return load(element); });
  assert(encodings.size() == prefix_encodings.size());
  return sourcemeta::jsonbinpack::FIXED_TYPED_ARRAY{
      .size = static_cast<std::uint64_t>(size.to_integer()),
      .encoding = std::make_shared<Encoding>(load(array_encoding)),
      .prefix_encodings = std::move(encodings)};
}

auto BOUNDED_8BITS_TYPED_ARRAY(const sourcemeta::core::JSON &options)
    -> Encoding {
  assert(options.defines("minimum"));
  assert(options.defines("maximum"));
  assert(options.defines("encoding"));
  assert(options.defines("prefixEncodings"));
  const auto &minimum{options.at("minimum")};
  const auto &maximum{options.at("maximum")};
  const auto &array_encoding{options.at("encoding")};
  const auto &prefix_encodings{options.at("prefixEncodings")};
  assert(minimum.is_integer());
  assert(maximum.is_integer());
  assert(minimum.is_positive());
  assert(maximum.is_positive());
  assert(array_encoding.is_object());
  assert(prefix_encodings.is_array());
  std::vector<Encoding> encodings;
  std::transform(prefix_encodings.as_array().cbegin(),
                 prefix_encodings.as_array().cend(),
                 std::back_inserter(encodings),
                 [](const auto &element) -> Encoding { return load(element); });
  assert(encodings.size() == prefix_encodings.size());
  return sourcemeta::jsonbinpack::BOUNDED_8BITS_TYPED_ARRAY{
      .minimum = static_cast<std::uint64_t>(minimum.to_integer()),
      .maximum = static_cast<std::uint64_t>(maximum.to_integer()),
      .encoding = std::make_shared<Encoding>(load(array_encoding)),
      .prefix_encodings = std::move(encodings)};
}

auto FLOOR_TYPED_ARRAY(const sourcemeta::core::JSON &options) -> Encoding {
  assert(options.defines("minimum"));
  assert(options.defines("encoding"));
  assert(options.defines("prefixEncodings"));
  const auto &minimum{options.at("minimum")};
  const auto &array_encoding{options.at("encoding")};
  const auto &prefix_encodings{options.at("prefixEncodings")};
  assert(minimum.is_integer());
  assert(minimum.is_positive());
  assert(array_encoding.is_object());
  assert(prefix_encodings.is_array());
  std::vector<Encoding> encodings;
  std::transform(prefix_encodings.as_array().cbegin(),
                 prefix_encodings.as_array().cend(),
                 std::back_inserter(encodings),
                 [](const auto &element) -> Encoding { return load(element); });
  assert(encodings.size() == prefix_encodings.size());
  return sourcemeta::jsonbinpack::FLOOR_TYPED_ARRAY{
      .minimum = static_cast<std::uint64_t>(minimum.to_integer()),
      .encoding = std::make_shared<Encoding>(load(array_encoding)),
      .prefix_encodings = std::move(encodings)};
}

auto ROOF_TYPED_ARRAY(const sourcemeta::core::JSON &options) -> Encoding {
  assert(options.defines("maximum"));
  assert(options.defines("encoding"));
  assert(options.defines("prefixEncodings"));
  const auto &maximum{options.at("maximum")};
  const auto &array_encoding{options.at("encoding")};
  const auto &prefix_encodings{options.at("prefixEncodings")};
  assert(maximum.is_integer());
  assert(maximum.is_positive());
  assert(array_encoding.is_object());
  assert(prefix_encodings.is_array());
  std::vector<Encoding> encodings;
  std::transform(prefix_encodings.as_array().cbegin(),
                 prefix_encodings.as_array().cend(),
                 std::back_inserter(encodings),
                 [](const auto &element) -> Encoding { return load(element); });
  assert(encodings.size() == prefix_encodings.size());
  return sourcemeta::jsonbinpack::ROOF_TYPED_ARRAY{
      .maximum = static_cast<std::uint64_t>(maximum.to_integer()),
      .encoding = std::make_shared<Encoding>(load(array_encoding)),
      .prefix_encodings = std::move(encodings)};
}

} // namespace sourcemeta::jsonbinpack::v1

#endif