1
// Copyright (c) 2017-2022 Cloudflare, Inc.
2
// Licensed under the Apache 2.0 license found in the LICENSE file or at:
3
//     https://opensource.org/licenses/Apache-2.0
4
 
5
#pragma once
6
 
7
#include <workerd/jsg/jsg.h>
8
 
9
namespace workerd::api {
10
 
11
constexpr uint MAX_INDEXES_LENGTH = 1;
12
constexpr size_t MAX_INDEX_SIZE_IN_BYTES = 96;
13
constexpr uint MAX_ARRAY_MEMBERS = 20;
14
constexpr size_t MAX_CUMULATIVE_BYTES_IN_BLOBS = 800 * MAX_ARRAY_MEMBERS;
15
 
16
template <typename Message>
17
void setDoubles(Message msg, kj::ArrayPtr<double> arr, kj::StringPtr errorPrefix) {
18
  JSG_REQUIRE(arr.size() <= MAX_ARRAY_MEMBERS, TypeError, errorPrefix, "Maximum of ",
19
      MAX_ARRAY_MEMBERS, " doubles supported.");
20
 
21
  uint index = 1;
22
  for (auto& item: arr) {
23
    switch (index) {
24
      case 1:
25
        msg.setDouble1(item);
26
        break;
27
      case 2:
28
        msg.setDouble2(item);
29
        break;
30
      case 3:
31
        msg.setDouble3(item);
32
        break;
33
      case 4:
34
        msg.setDouble4(item);
35
        break;
36
      case 5:
37
        msg.setDouble5(item);
38
        break;
39
      case 6:
40
        msg.setDouble6(item);
41
        break;
42
      case 7:
43
        msg.setDouble7(item);
44
        break;
45
      case 8:
46
        msg.setDouble8(item);
47
        break;
48
      case 9:
49
        msg.setDouble9(item);
50
        break;
51
      case 10:
52
        msg.setDouble10(item);
53
        break;
54
      case 11:
55
        msg.setDouble11(item);
56
        break;
57
      case 12:
58
        msg.setDouble12(item);
59
        break;
60
      case 13:
61
        msg.setDouble13(item);
62
        break;
63
      case 14:
64
        msg.setDouble14(item);
65
        break;
66
      case 15:
67
        msg.setDouble15(item);
68
        break;
69
      case 16:
70
        msg.setDouble16(item);
71
        break;
72
      case 17:
73
        msg.setDouble17(item);
74
        break;
75
      case 18:
76
        msg.setDouble18(item);
77
        break;
78
      case 19:
79
        msg.setDouble19(item);
80
        break;
81
      case 20:
82
        msg.setDouble20(item);
83
        break;
84
    }
85
    index++;
86
  }
87
}
88
 
89
template <typename Message>
90
void setBlobs(Message msg,
91
    kj::ArrayPtr<kj::Maybe<kj::OneOf<kj::Array<kj::byte>, kj::String>>> arr,
92
    kj::StringPtr errorPrefix) {
93
  JSG_REQUIRE(arr.size() <= MAX_ARRAY_MEMBERS, TypeError, errorPrefix, "Maximum of ",
94
      MAX_ARRAY_MEMBERS, " blobs supported.");
95
  kj::ArrayPtr<kj::byte> value;
96
  uint index = 1;
97
  size_t sizeSum = 0;
98
  for (auto& item: arr) {
99
    KJ_IF_SOME(i, item) {
100
      KJ_SWITCH_ONEOF(i) {
101
        KJ_CASE_ONEOF(val, kj::Array<kj::byte>) {
102
          value = val.asBytes();
103
        }
104
        KJ_CASE_ONEOF(val, kj::String) {
105
          value = val.asBytes();
106
        }
107
      }
108
      sizeSum += value.size();
109
      JSG_REQUIRE(sizeSum <= MAX_CUMULATIVE_BYTES_IN_BLOBS, TypeError, errorPrefix,
110
          "Cumulative size of blobs exceeds ", MAX_CUMULATIVE_BYTES_IN_BLOBS, " bytes).");
111
      switch (index) {
112
        case 1:
113
          msg.setBlob1(value);
114
          break;
115
        case 2:
116
          msg.setBlob2(value);
117
          break;
118
        case 3:
119
          msg.setBlob3(value);
120
          break;
121
        case 4:
122
          msg.setBlob4(value);
123
          break;
124
        case 5:
125
          msg.setBlob5(value);
126
          break;
127
        case 6:
128
          msg.setBlob6(value);
129
          break;
130
        case 7:
131
          msg.setBlob7(value);
132
          break;
133
        case 8:
134
          msg.setBlob8(value);
135
          break;
136
        case 9:
137
          msg.setBlob9(value);
138
          break;
139
        case 10:
140
          msg.setBlob10(value);
141
          break;
142
        case 11:
143
          msg.setBlob11(value);
144
          break;
145
        case 12:
146
          msg.setBlob12(value);
147
          break;
148
        case 13:
149
          msg.setBlob13(value);
150
          break;
151
        case 14:
152
          msg.setBlob14(value);
153
          break;
154
        case 15:
155
          msg.setBlob15(value);
156
          break;
157
        case 16:
158
          msg.setBlob16(value);
159
          break;
160
        case 17:
161
          msg.setBlob17(value);
162
          break;
163
        case 18:
164
          msg.setBlob18(value);
165
          break;
166
        case 19:
167
          msg.setBlob19(value);
168
          break;
169
        case 20:
170
          msg.setBlob20(value);
171
          break;
172
      }
173
    }
174
    index++;
175
  }
176
}
177
 
178
template <typename Message>
179
void setIndexes(Message msg,
180
    kj::ArrayPtr<kj::Maybe<kj::OneOf<kj::Array<kj::byte>, kj::String>>> arr,
181
    kj::StringPtr errorPrefix) {
182
  JSG_REQUIRE(arr.size() <= MAX_INDEXES_LENGTH, TypeError, errorPrefix, "Maximum of ",
183
      MAX_INDEXES_LENGTH, " indexes supported.");
184
  if (arr.size() == 0) {
185
    return;
186
  }
187
  auto item = kj::mv(arr[0]);
188
  kj::ArrayPtr<kj::byte> value;
189
  KJ_IF_SOME(i, item) {
190
    KJ_SWITCH_ONEOF(i) {
191
      KJ_CASE_ONEOF(val, kj::Array<kj::byte>) {
192
        value = val.asBytes();
193
      }
194
      KJ_CASE_ONEOF(val, kj::String) {
195
        value = val.asBytes();
196
      }
197
    }
198
    JSG_REQUIRE(value.size() <= MAX_INDEX_SIZE_IN_BYTES, TypeError, errorPrefix,
199
        "Size of indexes[0] exceeds ", MAX_INDEX_SIZE_IN_BYTES, " bytes).");
200
    msg.setIndex1(value);
201
  }
202
}
203
}  // namespace workerd::api