1 // automatically generated by the FlatBuffers compiler, do not modify
2 
3 
4 #ifndef FLATBUFFERS_GENERATED_EMBEDDINGNETWORK_LIBTEXTCLASSIFIER3_SAFT_FBS_H_
5 #define FLATBUFFERS_GENERATED_EMBEDDINGNETWORK_LIBTEXTCLASSIFIER3_SAFT_FBS_H_
6 
7 #include "flatbuffers/flatbuffers.h"
8 
9 // Ensure the included flatbuffers.h is the same version as when this file was
10 // generated, otherwise it may not be compatible.
11 static_assert(FLATBUFFERS_VERSION_MAJOR == 2 &&
12               FLATBUFFERS_VERSION_MINOR == 0 &&
13               FLATBUFFERS_VERSION_REVISION == 7,
14              "Non-compatible flatbuffers version included");
15 
16 namespace libtextclassifier3 {
17 namespace saft_fbs {
18 
19 struct Matrix;
20 struct MatrixBuilder;
21 struct MatrixT;
22 
23 struct InputChunk;
24 struct InputChunkBuilder;
25 struct InputChunkT;
26 
27 struct NeuralLayer;
28 struct NeuralLayerBuilder;
29 struct NeuralLayerT;
30 
31 struct EmbeddingNetwork;
32 struct EmbeddingNetworkBuilder;
33 struct EmbeddingNetworkT;
34 
35 enum QuantizationType : int8_t {
36   QuantizationType_NONE = 0,
37   QuantizationType_UINT8 = 1,
38   QuantizationType_UINT4 = 2,
39   QuantizationType_FLOAT16 = 3,
40   QuantizationType_MIN = QuantizationType_NONE,
41   QuantizationType_MAX = QuantizationType_FLOAT16
42 };
43 
EnumValuesQuantizationType()44 inline const QuantizationType (&EnumValuesQuantizationType())[4] {
45   static const QuantizationType values[] = {
46     QuantizationType_NONE,
47     QuantizationType_UINT8,
48     QuantizationType_UINT4,
49     QuantizationType_FLOAT16
50   };
51   return values;
52 }
53 
EnumNamesQuantizationType()54 inline const char * const *EnumNamesQuantizationType() {
55   static const char * const names[5] = {
56     "NONE",
57     "UINT8",
58     "UINT4",
59     "FLOAT16",
60     nullptr
61   };
62   return names;
63 }
64 
EnumNameQuantizationType(QuantizationType e)65 inline const char *EnumNameQuantizationType(QuantizationType e) {
66   if (flatbuffers::IsOutRange(e, QuantizationType_NONE, QuantizationType_FLOAT16)) return "";
67   const size_t index = static_cast<size_t>(e);
68   return EnumNamesQuantizationType()[index];
69 }
70 
71 struct MatrixT : public flatbuffers::NativeTable {
72   typedef Matrix TableType;
73   int32_t rows = 0;
74   int32_t cols = 0;
75   libtextclassifier3::saft_fbs::QuantizationType quantization_type = libtextclassifier3::saft_fbs::QuantizationType_NONE;
76   std::vector<float> values{};
77   std::vector<uint8_t> quantized_values{};
78   std::vector<uint16_t> scales{};
79 };
80 
81 struct Matrix FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
82   typedef MatrixT NativeTableType;
83   typedef MatrixBuilder Builder;
84   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
85     VT_ROWS = 4,
86     VT_COLS = 6,
87     VT_QUANTIZATION_TYPE = 8,
88     VT_VALUES = 10,
89     VT_QUANTIZED_VALUES = 12,
90     VT_SCALES = 14
91   };
rowsFLATBUFFERS_FINAL_CLASS92   int32_t rows() const {
93     return GetField<int32_t>(VT_ROWS, 0);
94   }
colsFLATBUFFERS_FINAL_CLASS95   int32_t cols() const {
96     return GetField<int32_t>(VT_COLS, 0);
97   }
quantization_typeFLATBUFFERS_FINAL_CLASS98   libtextclassifier3::saft_fbs::QuantizationType quantization_type() const {
99     return static_cast<libtextclassifier3::saft_fbs::QuantizationType>(GetField<int8_t>(VT_QUANTIZATION_TYPE, 0));
100   }
valuesFLATBUFFERS_FINAL_CLASS101   const flatbuffers::Vector<float> *values() const {
102     return GetPointer<const flatbuffers::Vector<float> *>(VT_VALUES);
103   }
quantized_valuesFLATBUFFERS_FINAL_CLASS104   const flatbuffers::Vector<uint8_t> *quantized_values() const {
105     return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_QUANTIZED_VALUES);
106   }
scalesFLATBUFFERS_FINAL_CLASS107   const flatbuffers::Vector<uint16_t> *scales() const {
108     return GetPointer<const flatbuffers::Vector<uint16_t> *>(VT_SCALES);
109   }
VerifyFLATBUFFERS_FINAL_CLASS110   bool Verify(flatbuffers::Verifier &verifier) const {
111     return VerifyTableStart(verifier) &&
112            VerifyField<int32_t>(verifier, VT_ROWS, 4) &&
113            VerifyField<int32_t>(verifier, VT_COLS, 4) &&
114            VerifyField<int8_t>(verifier, VT_QUANTIZATION_TYPE, 1) &&
115            VerifyOffset(verifier, VT_VALUES) &&
116            verifier.VerifyVector(values()) &&
117            VerifyOffset(verifier, VT_QUANTIZED_VALUES) &&
118            verifier.VerifyVector(quantized_values()) &&
119            VerifyOffset(verifier, VT_SCALES) &&
120            verifier.VerifyVector(scales()) &&
121            verifier.EndTable();
122   }
123   MatrixT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
124   void UnPackTo(MatrixT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
125   static flatbuffers::Offset<Matrix> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MatrixT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
126 };
127 
128 struct MatrixBuilder {
129   typedef Matrix Table;
130   flatbuffers::FlatBufferBuilder &fbb_;
131   flatbuffers::uoffset_t start_;
add_rowsMatrixBuilder132   void add_rows(int32_t rows) {
133     fbb_.AddElement<int32_t>(Matrix::VT_ROWS, rows, 0);
134   }
add_colsMatrixBuilder135   void add_cols(int32_t cols) {
136     fbb_.AddElement<int32_t>(Matrix::VT_COLS, cols, 0);
137   }
add_quantization_typeMatrixBuilder138   void add_quantization_type(libtextclassifier3::saft_fbs::QuantizationType quantization_type) {
139     fbb_.AddElement<int8_t>(Matrix::VT_QUANTIZATION_TYPE, static_cast<int8_t>(quantization_type), 0);
140   }
add_valuesMatrixBuilder141   void add_values(flatbuffers::Offset<flatbuffers::Vector<float>> values) {
142     fbb_.AddOffset(Matrix::VT_VALUES, values);
143   }
add_quantized_valuesMatrixBuilder144   void add_quantized_values(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> quantized_values) {
145     fbb_.AddOffset(Matrix::VT_QUANTIZED_VALUES, quantized_values);
146   }
add_scalesMatrixBuilder147   void add_scales(flatbuffers::Offset<flatbuffers::Vector<uint16_t>> scales) {
148     fbb_.AddOffset(Matrix::VT_SCALES, scales);
149   }
MatrixBuilderMatrixBuilder150   explicit MatrixBuilder(flatbuffers::FlatBufferBuilder &_fbb)
151         : fbb_(_fbb) {
152     start_ = fbb_.StartTable();
153   }
FinishMatrixBuilder154   flatbuffers::Offset<Matrix> Finish() {
155     const auto end = fbb_.EndTable(start_);
156     auto o = flatbuffers::Offset<Matrix>(end);
157     return o;
158   }
159 };
160 
161 inline flatbuffers::Offset<Matrix> CreateMatrix(
162     flatbuffers::FlatBufferBuilder &_fbb,
163     int32_t rows = 0,
164     int32_t cols = 0,
165     libtextclassifier3::saft_fbs::QuantizationType quantization_type = libtextclassifier3::saft_fbs::QuantizationType_NONE,
166     flatbuffers::Offset<flatbuffers::Vector<float>> values = 0,
167     flatbuffers::Offset<flatbuffers::Vector<uint8_t>> quantized_values = 0,
168     flatbuffers::Offset<flatbuffers::Vector<uint16_t>> scales = 0) {
169   MatrixBuilder builder_(_fbb);
170   builder_.add_scales(scales);
171   builder_.add_quantized_values(quantized_values);
172   builder_.add_values(values);
173   builder_.add_cols(cols);
174   builder_.add_rows(rows);
175   builder_.add_quantization_type(quantization_type);
176   return builder_.Finish();
177 }
178 
179 inline flatbuffers::Offset<Matrix> CreateMatrixDirect(
180     flatbuffers::FlatBufferBuilder &_fbb,
181     int32_t rows = 0,
182     int32_t cols = 0,
183     libtextclassifier3::saft_fbs::QuantizationType quantization_type = libtextclassifier3::saft_fbs::QuantizationType_NONE,
184     const std::vector<float> *values = nullptr,
185     const std::vector<uint8_t> *quantized_values = nullptr,
186     const std::vector<uint16_t> *scales = nullptr) {
187   auto values__ = values ? _fbb.CreateVector<float>(*values) : 0;
188   auto quantized_values__ = quantized_values ? _fbb.CreateVector<uint8_t>(*quantized_values) : 0;
189   auto scales__ = scales ? _fbb.CreateVector<uint16_t>(*scales) : 0;
190   return libtextclassifier3::saft_fbs::CreateMatrix(
191       _fbb,
192       rows,
193       cols,
194       quantization_type,
195       values__,
196       quantized_values__,
197       scales__);
198 }
199 
200 flatbuffers::Offset<Matrix> CreateMatrix(flatbuffers::FlatBufferBuilder &_fbb, const MatrixT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
201 
202 struct InputChunkT : public flatbuffers::NativeTable {
203   typedef InputChunk TableType;
204   std::unique_ptr<libtextclassifier3::saft_fbs::MatrixT> embedding{};
205   int32_t num_features = 0;
206   InputChunkT() = default;
207   InputChunkT(const InputChunkT &o);
208   InputChunkT(InputChunkT&&) FLATBUFFERS_NOEXCEPT = default;
209   InputChunkT &operator=(InputChunkT o) FLATBUFFERS_NOEXCEPT;
210 };
211 
212 struct InputChunk FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
213   typedef InputChunkT NativeTableType;
214   typedef InputChunkBuilder Builder;
215   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
216     VT_EMBEDDING = 4,
217     VT_NUM_FEATURES = 6
218   };
embeddingFLATBUFFERS_FINAL_CLASS219   const libtextclassifier3::saft_fbs::Matrix *embedding() const {
220     return GetPointer<const libtextclassifier3::saft_fbs::Matrix *>(VT_EMBEDDING);
221   }
num_featuresFLATBUFFERS_FINAL_CLASS222   int32_t num_features() const {
223     return GetField<int32_t>(VT_NUM_FEATURES, 0);
224   }
VerifyFLATBUFFERS_FINAL_CLASS225   bool Verify(flatbuffers::Verifier &verifier) const {
226     return VerifyTableStart(verifier) &&
227            VerifyOffset(verifier, VT_EMBEDDING) &&
228            verifier.VerifyTable(embedding()) &&
229            VerifyField<int32_t>(verifier, VT_NUM_FEATURES, 4) &&
230            verifier.EndTable();
231   }
232   InputChunkT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
233   void UnPackTo(InputChunkT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
234   static flatbuffers::Offset<InputChunk> Pack(flatbuffers::FlatBufferBuilder &_fbb, const InputChunkT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
235 };
236 
237 struct InputChunkBuilder {
238   typedef InputChunk Table;
239   flatbuffers::FlatBufferBuilder &fbb_;
240   flatbuffers::uoffset_t start_;
add_embeddingInputChunkBuilder241   void add_embedding(flatbuffers::Offset<libtextclassifier3::saft_fbs::Matrix> embedding) {
242     fbb_.AddOffset(InputChunk::VT_EMBEDDING, embedding);
243   }
add_num_featuresInputChunkBuilder244   void add_num_features(int32_t num_features) {
245     fbb_.AddElement<int32_t>(InputChunk::VT_NUM_FEATURES, num_features, 0);
246   }
InputChunkBuilderInputChunkBuilder247   explicit InputChunkBuilder(flatbuffers::FlatBufferBuilder &_fbb)
248         : fbb_(_fbb) {
249     start_ = fbb_.StartTable();
250   }
FinishInputChunkBuilder251   flatbuffers::Offset<InputChunk> Finish() {
252     const auto end = fbb_.EndTable(start_);
253     auto o = flatbuffers::Offset<InputChunk>(end);
254     return o;
255   }
256 };
257 
258 inline flatbuffers::Offset<InputChunk> CreateInputChunk(
259     flatbuffers::FlatBufferBuilder &_fbb,
260     flatbuffers::Offset<libtextclassifier3::saft_fbs::Matrix> embedding = 0,
261     int32_t num_features = 0) {
262   InputChunkBuilder builder_(_fbb);
263   builder_.add_num_features(num_features);
264   builder_.add_embedding(embedding);
265   return builder_.Finish();
266 }
267 
268 flatbuffers::Offset<InputChunk> CreateInputChunk(flatbuffers::FlatBufferBuilder &_fbb, const InputChunkT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
269 
270 struct NeuralLayerT : public flatbuffers::NativeTable {
271   typedef NeuralLayer TableType;
272   std::unique_ptr<libtextclassifier3::saft_fbs::MatrixT> weights{};
273   std::unique_ptr<libtextclassifier3::saft_fbs::MatrixT> bias{};
274   NeuralLayerT() = default;
275   NeuralLayerT(const NeuralLayerT &o);
276   NeuralLayerT(NeuralLayerT&&) FLATBUFFERS_NOEXCEPT = default;
277   NeuralLayerT &operator=(NeuralLayerT o) FLATBUFFERS_NOEXCEPT;
278 };
279 
280 struct NeuralLayer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
281   typedef NeuralLayerT NativeTableType;
282   typedef NeuralLayerBuilder Builder;
283   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
284     VT_WEIGHTS = 4,
285     VT_BIAS = 6
286   };
weightsFLATBUFFERS_FINAL_CLASS287   const libtextclassifier3::saft_fbs::Matrix *weights() const {
288     return GetPointer<const libtextclassifier3::saft_fbs::Matrix *>(VT_WEIGHTS);
289   }
biasFLATBUFFERS_FINAL_CLASS290   const libtextclassifier3::saft_fbs::Matrix *bias() const {
291     return GetPointer<const libtextclassifier3::saft_fbs::Matrix *>(VT_BIAS);
292   }
VerifyFLATBUFFERS_FINAL_CLASS293   bool Verify(flatbuffers::Verifier &verifier) const {
294     return VerifyTableStart(verifier) &&
295            VerifyOffset(verifier, VT_WEIGHTS) &&
296            verifier.VerifyTable(weights()) &&
297            VerifyOffset(verifier, VT_BIAS) &&
298            verifier.VerifyTable(bias()) &&
299            verifier.EndTable();
300   }
301   NeuralLayerT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
302   void UnPackTo(NeuralLayerT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
303   static flatbuffers::Offset<NeuralLayer> Pack(flatbuffers::FlatBufferBuilder &_fbb, const NeuralLayerT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
304 };
305 
306 struct NeuralLayerBuilder {
307   typedef NeuralLayer Table;
308   flatbuffers::FlatBufferBuilder &fbb_;
309   flatbuffers::uoffset_t start_;
add_weightsNeuralLayerBuilder310   void add_weights(flatbuffers::Offset<libtextclassifier3::saft_fbs::Matrix> weights) {
311     fbb_.AddOffset(NeuralLayer::VT_WEIGHTS, weights);
312   }
add_biasNeuralLayerBuilder313   void add_bias(flatbuffers::Offset<libtextclassifier3::saft_fbs::Matrix> bias) {
314     fbb_.AddOffset(NeuralLayer::VT_BIAS, bias);
315   }
NeuralLayerBuilderNeuralLayerBuilder316   explicit NeuralLayerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
317         : fbb_(_fbb) {
318     start_ = fbb_.StartTable();
319   }
FinishNeuralLayerBuilder320   flatbuffers::Offset<NeuralLayer> Finish() {
321     const auto end = fbb_.EndTable(start_);
322     auto o = flatbuffers::Offset<NeuralLayer>(end);
323     return o;
324   }
325 };
326 
327 inline flatbuffers::Offset<NeuralLayer> CreateNeuralLayer(
328     flatbuffers::FlatBufferBuilder &_fbb,
329     flatbuffers::Offset<libtextclassifier3::saft_fbs::Matrix> weights = 0,
330     flatbuffers::Offset<libtextclassifier3::saft_fbs::Matrix> bias = 0) {
331   NeuralLayerBuilder builder_(_fbb);
332   builder_.add_bias(bias);
333   builder_.add_weights(weights);
334   return builder_.Finish();
335 }
336 
337 flatbuffers::Offset<NeuralLayer> CreateNeuralLayer(flatbuffers::FlatBufferBuilder &_fbb, const NeuralLayerT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
338 
339 struct EmbeddingNetworkT : public flatbuffers::NativeTable {
340   typedef EmbeddingNetwork TableType;
341   std::vector<std::unique_ptr<libtextclassifier3::saft_fbs::InputChunkT>> input_chunks{};
342   std::vector<std::unique_ptr<libtextclassifier3::saft_fbs::NeuralLayerT>> layers{};
343   EmbeddingNetworkT() = default;
344   EmbeddingNetworkT(const EmbeddingNetworkT &o);
345   EmbeddingNetworkT(EmbeddingNetworkT&&) FLATBUFFERS_NOEXCEPT = default;
346   EmbeddingNetworkT &operator=(EmbeddingNetworkT o) FLATBUFFERS_NOEXCEPT;
347 };
348 
349 struct EmbeddingNetwork FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
350   typedef EmbeddingNetworkT NativeTableType;
351   typedef EmbeddingNetworkBuilder Builder;
352   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
353     VT_INPUT_CHUNKS = 4,
354     VT_LAYERS = 6
355   };
input_chunksFLATBUFFERS_FINAL_CLASS356   const flatbuffers::Vector<flatbuffers::Offset<libtextclassifier3::saft_fbs::InputChunk>> *input_chunks() const {
357     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<libtextclassifier3::saft_fbs::InputChunk>> *>(VT_INPUT_CHUNKS);
358   }
layersFLATBUFFERS_FINAL_CLASS359   const flatbuffers::Vector<flatbuffers::Offset<libtextclassifier3::saft_fbs::NeuralLayer>> *layers() const {
360     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<libtextclassifier3::saft_fbs::NeuralLayer>> *>(VT_LAYERS);
361   }
VerifyFLATBUFFERS_FINAL_CLASS362   bool Verify(flatbuffers::Verifier &verifier) const {
363     return VerifyTableStart(verifier) &&
364            VerifyOffset(verifier, VT_INPUT_CHUNKS) &&
365            verifier.VerifyVector(input_chunks()) &&
366            verifier.VerifyVectorOfTables(input_chunks()) &&
367            VerifyOffset(verifier, VT_LAYERS) &&
368            verifier.VerifyVector(layers()) &&
369            verifier.VerifyVectorOfTables(layers()) &&
370            verifier.EndTable();
371   }
372   EmbeddingNetworkT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
373   void UnPackTo(EmbeddingNetworkT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
374   static flatbuffers::Offset<EmbeddingNetwork> Pack(flatbuffers::FlatBufferBuilder &_fbb, const EmbeddingNetworkT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
375 };
376 
377 struct EmbeddingNetworkBuilder {
378   typedef EmbeddingNetwork Table;
379   flatbuffers::FlatBufferBuilder &fbb_;
380   flatbuffers::uoffset_t start_;
add_input_chunksEmbeddingNetworkBuilder381   void add_input_chunks(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<libtextclassifier3::saft_fbs::InputChunk>>> input_chunks) {
382     fbb_.AddOffset(EmbeddingNetwork::VT_INPUT_CHUNKS, input_chunks);
383   }
add_layersEmbeddingNetworkBuilder384   void add_layers(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<libtextclassifier3::saft_fbs::NeuralLayer>>> layers) {
385     fbb_.AddOffset(EmbeddingNetwork::VT_LAYERS, layers);
386   }
EmbeddingNetworkBuilderEmbeddingNetworkBuilder387   explicit EmbeddingNetworkBuilder(flatbuffers::FlatBufferBuilder &_fbb)
388         : fbb_(_fbb) {
389     start_ = fbb_.StartTable();
390   }
FinishEmbeddingNetworkBuilder391   flatbuffers::Offset<EmbeddingNetwork> Finish() {
392     const auto end = fbb_.EndTable(start_);
393     auto o = flatbuffers::Offset<EmbeddingNetwork>(end);
394     return o;
395   }
396 };
397 
398 inline flatbuffers::Offset<EmbeddingNetwork> CreateEmbeddingNetwork(
399     flatbuffers::FlatBufferBuilder &_fbb,
400     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<libtextclassifier3::saft_fbs::InputChunk>>> input_chunks = 0,
401     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<libtextclassifier3::saft_fbs::NeuralLayer>>> layers = 0) {
402   EmbeddingNetworkBuilder builder_(_fbb);
403   builder_.add_layers(layers);
404   builder_.add_input_chunks(input_chunks);
405   return builder_.Finish();
406 }
407 
408 inline flatbuffers::Offset<EmbeddingNetwork> CreateEmbeddingNetworkDirect(
409     flatbuffers::FlatBufferBuilder &_fbb,
410     const std::vector<flatbuffers::Offset<libtextclassifier3::saft_fbs::InputChunk>> *input_chunks = nullptr,
411     const std::vector<flatbuffers::Offset<libtextclassifier3::saft_fbs::NeuralLayer>> *layers = nullptr) {
412   auto input_chunks__ = input_chunks ? _fbb.CreateVector<flatbuffers::Offset<libtextclassifier3::saft_fbs::InputChunk>>(*input_chunks) : 0;
413   auto layers__ = layers ? _fbb.CreateVector<flatbuffers::Offset<libtextclassifier3::saft_fbs::NeuralLayer>>(*layers) : 0;
414   return libtextclassifier3::saft_fbs::CreateEmbeddingNetwork(
415       _fbb,
416       input_chunks__,
417       layers__);
418 }
419 
420 flatbuffers::Offset<EmbeddingNetwork> CreateEmbeddingNetwork(flatbuffers::FlatBufferBuilder &_fbb, const EmbeddingNetworkT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
421 
UnPack(const flatbuffers::resolver_function_t * _resolver)422 inline MatrixT *Matrix::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
423   auto _o = std::unique_ptr<MatrixT>(new MatrixT());
424   UnPackTo(_o.get(), _resolver);
425   return _o.release();
426 }
427 
UnPackTo(MatrixT * _o,const flatbuffers::resolver_function_t * _resolver)428 inline void Matrix::UnPackTo(MatrixT *_o, const flatbuffers::resolver_function_t *_resolver) const {
429   (void)_o;
430   (void)_resolver;
431   { auto _e = rows(); _o->rows = _e; }
432   { auto _e = cols(); _o->cols = _e; }
433   { auto _e = quantization_type(); _o->quantization_type = _e; }
434   { auto _e = values(); if (_e) { _o->values.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->values[_i] = _e->Get(_i); } } }
435   { auto _e = quantized_values(); if (_e) { _o->quantized_values.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->quantized_values.begin()); } }
436   { auto _e = scales(); if (_e) { _o->scales.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->scales[_i] = _e->Get(_i); } } }
437 }
438 
Pack(flatbuffers::FlatBufferBuilder & _fbb,const MatrixT * _o,const flatbuffers::rehasher_function_t * _rehasher)439 inline flatbuffers::Offset<Matrix> Matrix::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MatrixT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
440   return CreateMatrix(_fbb, _o, _rehasher);
441 }
442 
CreateMatrix(flatbuffers::FlatBufferBuilder & _fbb,const MatrixT * _o,const flatbuffers::rehasher_function_t * _rehasher)443 inline flatbuffers::Offset<Matrix> CreateMatrix(flatbuffers::FlatBufferBuilder &_fbb, const MatrixT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
444   (void)_rehasher;
445   (void)_o;
446   struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const MatrixT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
447   auto _rows = _o->rows;
448   auto _cols = _o->cols;
449   auto _quantization_type = _o->quantization_type;
450   auto _values = _o->values.size() ? _fbb.CreateVector(_o->values) : 0;
451   auto _quantized_values = _o->quantized_values.size() ? _fbb.CreateVector(_o->quantized_values) : 0;
452   auto _scales = _o->scales.size() ? _fbb.CreateVector(_o->scales) : 0;
453   return libtextclassifier3::saft_fbs::CreateMatrix(
454       _fbb,
455       _rows,
456       _cols,
457       _quantization_type,
458       _values,
459       _quantized_values,
460       _scales);
461 }
462 
InputChunkT(const InputChunkT & o)463 inline InputChunkT::InputChunkT(const InputChunkT &o)
464       : embedding((o.embedding) ? new libtextclassifier3::saft_fbs::MatrixT(*o.embedding) : nullptr),
465         num_features(o.num_features) {
466 }
467 
468 inline InputChunkT &InputChunkT::operator=(InputChunkT o) FLATBUFFERS_NOEXCEPT {
469   std::swap(embedding, o.embedding);
470   std::swap(num_features, o.num_features);
471   return *this;
472 }
473 
UnPack(const flatbuffers::resolver_function_t * _resolver)474 inline InputChunkT *InputChunk::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
475   auto _o = std::unique_ptr<InputChunkT>(new InputChunkT());
476   UnPackTo(_o.get(), _resolver);
477   return _o.release();
478 }
479 
UnPackTo(InputChunkT * _o,const flatbuffers::resolver_function_t * _resolver)480 inline void InputChunk::UnPackTo(InputChunkT *_o, const flatbuffers::resolver_function_t *_resolver) const {
481   (void)_o;
482   (void)_resolver;
483   { auto _e = embedding(); if (_e) _o->embedding = std::unique_ptr<libtextclassifier3::saft_fbs::MatrixT>(_e->UnPack(_resolver)); }
484   { auto _e = num_features(); _o->num_features = _e; }
485 }
486 
Pack(flatbuffers::FlatBufferBuilder & _fbb,const InputChunkT * _o,const flatbuffers::rehasher_function_t * _rehasher)487 inline flatbuffers::Offset<InputChunk> InputChunk::Pack(flatbuffers::FlatBufferBuilder &_fbb, const InputChunkT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
488   return CreateInputChunk(_fbb, _o, _rehasher);
489 }
490 
CreateInputChunk(flatbuffers::FlatBufferBuilder & _fbb,const InputChunkT * _o,const flatbuffers::rehasher_function_t * _rehasher)491 inline flatbuffers::Offset<InputChunk> CreateInputChunk(flatbuffers::FlatBufferBuilder &_fbb, const InputChunkT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
492   (void)_rehasher;
493   (void)_o;
494   struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const InputChunkT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
495   auto _embedding = _o->embedding ? CreateMatrix(_fbb, _o->embedding.get(), _rehasher) : 0;
496   auto _num_features = _o->num_features;
497   return libtextclassifier3::saft_fbs::CreateInputChunk(
498       _fbb,
499       _embedding,
500       _num_features);
501 }
502 
NeuralLayerT(const NeuralLayerT & o)503 inline NeuralLayerT::NeuralLayerT(const NeuralLayerT &o)
504       : weights((o.weights) ? new libtextclassifier3::saft_fbs::MatrixT(*o.weights) : nullptr),
505         bias((o.bias) ? new libtextclassifier3::saft_fbs::MatrixT(*o.bias) : nullptr) {
506 }
507 
508 inline NeuralLayerT &NeuralLayerT::operator=(NeuralLayerT o) FLATBUFFERS_NOEXCEPT {
509   std::swap(weights, o.weights);
510   std::swap(bias, o.bias);
511   return *this;
512 }
513 
UnPack(const flatbuffers::resolver_function_t * _resolver)514 inline NeuralLayerT *NeuralLayer::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
515   auto _o = std::unique_ptr<NeuralLayerT>(new NeuralLayerT());
516   UnPackTo(_o.get(), _resolver);
517   return _o.release();
518 }
519 
UnPackTo(NeuralLayerT * _o,const flatbuffers::resolver_function_t * _resolver)520 inline void NeuralLayer::UnPackTo(NeuralLayerT *_o, const flatbuffers::resolver_function_t *_resolver) const {
521   (void)_o;
522   (void)_resolver;
523   { auto _e = weights(); if (_e) _o->weights = std::unique_ptr<libtextclassifier3::saft_fbs::MatrixT>(_e->UnPack(_resolver)); }
524   { auto _e = bias(); if (_e) _o->bias = std::unique_ptr<libtextclassifier3::saft_fbs::MatrixT>(_e->UnPack(_resolver)); }
525 }
526 
Pack(flatbuffers::FlatBufferBuilder & _fbb,const NeuralLayerT * _o,const flatbuffers::rehasher_function_t * _rehasher)527 inline flatbuffers::Offset<NeuralLayer> NeuralLayer::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NeuralLayerT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
528   return CreateNeuralLayer(_fbb, _o, _rehasher);
529 }
530 
CreateNeuralLayer(flatbuffers::FlatBufferBuilder & _fbb,const NeuralLayerT * _o,const flatbuffers::rehasher_function_t * _rehasher)531 inline flatbuffers::Offset<NeuralLayer> CreateNeuralLayer(flatbuffers::FlatBufferBuilder &_fbb, const NeuralLayerT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
532   (void)_rehasher;
533   (void)_o;
534   struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const NeuralLayerT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
535   auto _weights = _o->weights ? CreateMatrix(_fbb, _o->weights.get(), _rehasher) : 0;
536   auto _bias = _o->bias ? CreateMatrix(_fbb, _o->bias.get(), _rehasher) : 0;
537   return libtextclassifier3::saft_fbs::CreateNeuralLayer(
538       _fbb,
539       _weights,
540       _bias);
541 }
542 
EmbeddingNetworkT(const EmbeddingNetworkT & o)543 inline EmbeddingNetworkT::EmbeddingNetworkT(const EmbeddingNetworkT &o) {
544   input_chunks.reserve(o.input_chunks.size());
545   for (const auto &input_chunks_ : o.input_chunks) { input_chunks.emplace_back((input_chunks_) ? new libtextclassifier3::saft_fbs::InputChunkT(*input_chunks_) : nullptr); }
546   layers.reserve(o.layers.size());
547   for (const auto &layers_ : o.layers) { layers.emplace_back((layers_) ? new libtextclassifier3::saft_fbs::NeuralLayerT(*layers_) : nullptr); }
548 }
549 
550 inline EmbeddingNetworkT &EmbeddingNetworkT::operator=(EmbeddingNetworkT o) FLATBUFFERS_NOEXCEPT {
551   std::swap(input_chunks, o.input_chunks);
552   std::swap(layers, o.layers);
553   return *this;
554 }
555 
UnPack(const flatbuffers::resolver_function_t * _resolver)556 inline EmbeddingNetworkT *EmbeddingNetwork::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
557   auto _o = std::unique_ptr<EmbeddingNetworkT>(new EmbeddingNetworkT());
558   UnPackTo(_o.get(), _resolver);
559   return _o.release();
560 }
561 
UnPackTo(EmbeddingNetworkT * _o,const flatbuffers::resolver_function_t * _resolver)562 inline void EmbeddingNetwork::UnPackTo(EmbeddingNetworkT *_o, const flatbuffers::resolver_function_t *_resolver) const {
563   (void)_o;
564   (void)_resolver;
565   { auto _e = input_chunks(); if (_e) { _o->input_chunks.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->input_chunks[_i] = std::unique_ptr<libtextclassifier3::saft_fbs::InputChunkT>(_e->Get(_i)->UnPack(_resolver)); } } }
566   { auto _e = layers(); if (_e) { _o->layers.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->layers[_i] = std::unique_ptr<libtextclassifier3::saft_fbs::NeuralLayerT>(_e->Get(_i)->UnPack(_resolver)); } } }
567 }
568 
Pack(flatbuffers::FlatBufferBuilder & _fbb,const EmbeddingNetworkT * _o,const flatbuffers::rehasher_function_t * _rehasher)569 inline flatbuffers::Offset<EmbeddingNetwork> EmbeddingNetwork::Pack(flatbuffers::FlatBufferBuilder &_fbb, const EmbeddingNetworkT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
570   return CreateEmbeddingNetwork(_fbb, _o, _rehasher);
571 }
572 
CreateEmbeddingNetwork(flatbuffers::FlatBufferBuilder & _fbb,const EmbeddingNetworkT * _o,const flatbuffers::rehasher_function_t * _rehasher)573 inline flatbuffers::Offset<EmbeddingNetwork> CreateEmbeddingNetwork(flatbuffers::FlatBufferBuilder &_fbb, const EmbeddingNetworkT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
574   (void)_rehasher;
575   (void)_o;
576   struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const EmbeddingNetworkT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
577   auto _input_chunks = _o->input_chunks.size() ? _fbb.CreateVector<flatbuffers::Offset<libtextclassifier3::saft_fbs::InputChunk>> (_o->input_chunks.size(), [](size_t i, _VectorArgs *__va) { return CreateInputChunk(*__va->__fbb, __va->__o->input_chunks[i].get(), __va->__rehasher); }, &_va ) : 0;
578   auto _layers = _o->layers.size() ? _fbb.CreateVector<flatbuffers::Offset<libtextclassifier3::saft_fbs::NeuralLayer>> (_o->layers.size(), [](size_t i, _VectorArgs *__va) { return CreateNeuralLayer(*__va->__fbb, __va->__o->layers[i].get(), __va->__rehasher); }, &_va ) : 0;
579   return libtextclassifier3::saft_fbs::CreateEmbeddingNetwork(
580       _fbb,
581       _input_chunks,
582       _layers);
583 }
584 
GetEmbeddingNetwork(const void * buf)585 inline const libtextclassifier3::saft_fbs::EmbeddingNetwork *GetEmbeddingNetwork(const void *buf) {
586   return flatbuffers::GetRoot<libtextclassifier3::saft_fbs::EmbeddingNetwork>(buf);
587 }
588 
GetSizePrefixedEmbeddingNetwork(const void * buf)589 inline const libtextclassifier3::saft_fbs::EmbeddingNetwork *GetSizePrefixedEmbeddingNetwork(const void *buf) {
590   return flatbuffers::GetSizePrefixedRoot<libtextclassifier3::saft_fbs::EmbeddingNetwork>(buf);
591 }
592 
EmbeddingNetworkIdentifier()593 inline const char *EmbeddingNetworkIdentifier() {
594   return "NS00";
595 }
596 
EmbeddingNetworkBufferHasIdentifier(const void * buf)597 inline bool EmbeddingNetworkBufferHasIdentifier(const void *buf) {
598   return flatbuffers::BufferHasIdentifier(
599       buf, EmbeddingNetworkIdentifier());
600 }
601 
SizePrefixedEmbeddingNetworkBufferHasIdentifier(const void * buf)602 inline bool SizePrefixedEmbeddingNetworkBufferHasIdentifier(const void *buf) {
603   return flatbuffers::BufferHasIdentifier(
604       buf, EmbeddingNetworkIdentifier(), true);
605 }
606 
VerifyEmbeddingNetworkBuffer(flatbuffers::Verifier & verifier)607 inline bool VerifyEmbeddingNetworkBuffer(
608     flatbuffers::Verifier &verifier) {
609   return verifier.VerifyBuffer<libtextclassifier3::saft_fbs::EmbeddingNetwork>(EmbeddingNetworkIdentifier());
610 }
611 
VerifySizePrefixedEmbeddingNetworkBuffer(flatbuffers::Verifier & verifier)612 inline bool VerifySizePrefixedEmbeddingNetworkBuffer(
613     flatbuffers::Verifier &verifier) {
614   return verifier.VerifySizePrefixedBuffer<libtextclassifier3::saft_fbs::EmbeddingNetwork>(EmbeddingNetworkIdentifier());
615 }
616 
FinishEmbeddingNetworkBuffer(flatbuffers::FlatBufferBuilder & fbb,flatbuffers::Offset<libtextclassifier3::saft_fbs::EmbeddingNetwork> root)617 inline void FinishEmbeddingNetworkBuffer(
618     flatbuffers::FlatBufferBuilder &fbb,
619     flatbuffers::Offset<libtextclassifier3::saft_fbs::EmbeddingNetwork> root) {
620   fbb.Finish(root, EmbeddingNetworkIdentifier());
621 }
622 
FinishSizePrefixedEmbeddingNetworkBuffer(flatbuffers::FlatBufferBuilder & fbb,flatbuffers::Offset<libtextclassifier3::saft_fbs::EmbeddingNetwork> root)623 inline void FinishSizePrefixedEmbeddingNetworkBuffer(
624     flatbuffers::FlatBufferBuilder &fbb,
625     flatbuffers::Offset<libtextclassifier3::saft_fbs::EmbeddingNetwork> root) {
626   fbb.FinishSizePrefixed(root, EmbeddingNetworkIdentifier());
627 }
628 
629 inline std::unique_ptr<libtextclassifier3::saft_fbs::EmbeddingNetworkT> UnPackEmbeddingNetwork(
630     const void *buf,
631     const flatbuffers::resolver_function_t *res = nullptr) {
632   return std::unique_ptr<libtextclassifier3::saft_fbs::EmbeddingNetworkT>(GetEmbeddingNetwork(buf)->UnPack(res));
633 }
634 
635 inline std::unique_ptr<libtextclassifier3::saft_fbs::EmbeddingNetworkT> UnPackSizePrefixedEmbeddingNetwork(
636     const void *buf,
637     const flatbuffers::resolver_function_t *res = nullptr) {
638   return std::unique_ptr<libtextclassifier3::saft_fbs::EmbeddingNetworkT>(GetSizePrefixedEmbeddingNetwork(buf)->UnPack(res));
639 }
640 
641 }  // namespace saft_fbs
642 }  // namespace libtextclassifier3
643 
644 #endif  // FLATBUFFERS_GENERATED_EMBEDDINGNETWORK_LIBTEXTCLASSIFIER3_SAFT_FBS_H_
645