Flutter Linux Embedder
fl_standard_message_codec.cc
Go to the documentation of this file.
1 // Copyright 2013 The Flutter Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 
7 
8 #include <gmodule.h>
9 
10 #include <cstring>
11 
12 // See lib/src/services/message_codecs.dart in Flutter source for description of
13 // encoding.
14 
15 // Type values.
16 static constexpr int kValueNull = 0;
17 static constexpr int kValueTrue = 1;
18 static constexpr int kValueFalse = 2;
19 static constexpr int kValueInt32 = 3;
20 static constexpr int kValueInt64 = 4;
21 static constexpr int kValueFloat64 = 6;
22 static constexpr int kValueString = 7;
23 static constexpr int kValueUint8List = 8;
24 static constexpr int kValueInt32List = 9;
25 static constexpr int kValueInt64List = 10;
26 static constexpr int kValueFloat64List = 11;
27 static constexpr int kValueList = 12;
28 static constexpr int kValueMap = 13;
29 static constexpr int kValueFloat32List = 14;
30 
32  FlMessageCodec parent_instance;
33 };
34 
35 G_DEFINE_TYPE(FlStandardMessageCodec,
36  fl_standard_message_codec,
37  fl_message_codec_get_type())
38 
39 // Functions to write standard C number types.
40 
41 static void write_uint8(GByteArray* buffer, uint8_t value) {
42  g_byte_array_append(buffer, &value, sizeof(uint8_t));
43 }
44 
45 static void write_uint16(GByteArray* buffer, uint16_t value) {
46  g_byte_array_append(buffer, reinterpret_cast<uint8_t*>(&value),
47  sizeof(uint16_t));
48 }
49 
50 static void write_uint32(GByteArray* buffer, uint32_t value) {
51  g_byte_array_append(buffer, reinterpret_cast<uint8_t*>(&value),
52  sizeof(uint32_t));
53 }
54 
55 static void write_int32(GByteArray* buffer, int32_t value) {
56  g_byte_array_append(buffer, reinterpret_cast<uint8_t*>(&value),
57  sizeof(int32_t));
58 }
59 
60 static void write_int64(GByteArray* buffer, int64_t value) {
61  g_byte_array_append(buffer, reinterpret_cast<uint8_t*>(&value),
62  sizeof(int64_t));
63 }
64 
65 static void write_float64(GByteArray* buffer, double value) {
66  g_byte_array_append(buffer, reinterpret_cast<uint8_t*>(&value),
67  sizeof(double));
68 }
69 
70 // Write padding bytes to align to @align multiple of bytes.
71 static void write_align(GByteArray* buffer, guint align) {
72  while (buffer->len % align != 0) {
73  write_uint8(buffer, 0);
74  }
75 }
76 
77 // Checks there is enough data in @buffer to be read.
78 static gboolean check_size(GBytes* buffer,
79  size_t offset,
80  size_t required,
81  GError** error) {
82  if (offset + required > g_bytes_get_size(buffer)) {
83  g_set_error(error, FL_MESSAGE_CODEC_ERROR,
84  FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA, "Unexpected end of data");
85  return FALSE;
86  }
87  return TRUE;
88 }
89 
90 // Skip bytes to align next read on @align multiple of bytes.
91 static gboolean read_align(GBytes* buffer,
92  size_t* offset,
93  size_t align,
94  GError** error) {
95  if ((*offset) % align == 0) {
96  return TRUE;
97  }
98 
99  size_t required = align - (*offset) % align;
100  if (!check_size(buffer, *offset, required, error)) {
101  return FALSE;
102  }
103 
104  (*offset) += required;
105  return TRUE;
106 }
107 
108 // Gets a pointer to the given offset in @buffer.
109 static const uint8_t* get_data(GBytes* buffer, size_t* offset) {
110  return static_cast<const uint8_t*>(g_bytes_get_data(buffer, nullptr)) +
111  *offset;
112 }
113 
114 // Reads an unsigned 8 bit number from @buffer and writes it to @value.
115 // Returns TRUE if successful, otherwise sets an error.
116 static gboolean read_uint8(GBytes* buffer,
117  size_t* offset,
118  uint8_t* value,
119  GError** error) {
120  if (!check_size(buffer, *offset, sizeof(uint8_t), error)) {
121  return FALSE;
122  }
123 
124  *value = get_data(buffer, offset)[0];
125  (*offset)++;
126  return TRUE;
127 }
128 
129 // Reads an unsigned 16 bit integer from @buffer and writes it to @value.
130 // Returns TRUE if successful, otherwise sets an error.
131 static gboolean read_uint16(GBytes* buffer,
132  size_t* offset,
133  uint16_t* value,
134  GError** error) {
135  if (!check_size(buffer, *offset, sizeof(uint16_t), error)) {
136  return FALSE;
137  }
138 
139  *value = reinterpret_cast<const uint16_t*>(get_data(buffer, offset))[0];
140  *offset += sizeof(uint16_t);
141  return TRUE;
142 }
143 
144 // Reads an unsigned 32 bit integer from @buffer and writes it to @value.
145 // Returns TRUE if successful, otherwise sets an error.
146 static gboolean read_uint32(GBytes* buffer,
147  size_t* offset,
148  uint32_t* value,
149  GError** error) {
150  if (!check_size(buffer, *offset, sizeof(uint32_t), error)) {
151  return FALSE;
152  }
153 
154  *value = reinterpret_cast<const uint32_t*>(get_data(buffer, offset))[0];
155  *offset += sizeof(uint32_t);
156  return TRUE;
157 }
158 
159 // Reads a #FL_VALUE_TYPE_INT stored as a signed 32 bit integer from @buffer.
160 // Returns a new #FlValue of type #FL_VALUE_TYPE_INT if successful or %NULL on
161 // error.
163  size_t* offset,
164  GError** error) {
165  if (!check_size(buffer, *offset, sizeof(int32_t), error)) {
166  return nullptr;
167  }
168 
170  reinterpret_cast<const int32_t*>(get_data(buffer, offset))[0]);
171  *offset += sizeof(int32_t);
172  return value;
173 }
174 
175 // Reads a #FL_VALUE_TYPE_INT stored as a signed 64 bit integer from @buffer.
176 // Returns a new #FlValue of type #FL_VALUE_TYPE_INT if successful or %NULL on
177 // error.
179  size_t* offset,
180  GError** error) {
181  if (!check_size(buffer, *offset, sizeof(int64_t), error)) {
182  return nullptr;
183  }
184 
186  reinterpret_cast<const int64_t*>(get_data(buffer, offset))[0]);
187  *offset += sizeof(int64_t);
188  return value;
189 }
190 
191 // Reads a 64 bit floating point number from @buffer and writes it to @value.
192 // Returns a new #FlValue of type #FL_VALUE_TYPE_FLOAT if successful or %NULL on
193 // error.
195  size_t* offset,
196  GError** error) {
197  if (!read_align(buffer, offset, 8, error)) {
198  return nullptr;
199  }
200  if (!check_size(buffer, *offset, sizeof(double), error)) {
201  return nullptr;
202  }
203 
205  reinterpret_cast<const double*>(get_data(buffer, offset))[0]);
206  *offset += sizeof(double);
207  return value;
208 }
209 
210 // Reads an UTF-8 text string from @buffer in standard codec format.
211 // Returns a new #FlValue of type #FL_VALUE_TYPE_STRING if successful or %NULL
212 // on error.
213 static FlValue* read_string_value(FlStandardMessageCodec* self,
214  GBytes* buffer,
215  size_t* offset,
216  GError** error) {
217  uint32_t length;
218  if (!fl_standard_message_codec_read_size(self, buffer, offset, &length,
219  error)) {
220  return nullptr;
221  }
222  if (!check_size(buffer, *offset, length, error)) {
223  return nullptr;
224  }
226  reinterpret_cast<const gchar*>(get_data(buffer, offset)), length);
227  *offset += length;
228  return value;
229 }
230 
231 // Reads an unsigned 8 bit list from @buffer in standard codec format.
232 // Returns a new #FlValue of type #FL_VALUE_TYPE_UINT8_LIST if successful or
233 // %NULL on error.
234 static FlValue* read_uint8_list_value(FlStandardMessageCodec* self,
235  GBytes* buffer,
236  size_t* offset,
237  GError** error) {
238  uint32_t length;
239  if (!fl_standard_message_codec_read_size(self, buffer, offset, &length,
240  error)) {
241  return nullptr;
242  }
243  if (!check_size(buffer, *offset, sizeof(uint8_t) * length, error)) {
244  return nullptr;
245  }
246  FlValue* value = fl_value_new_uint8_list(get_data(buffer, offset), length);
247  *offset += length;
248  return value;
249 }
250 
251 // Reads a signed 32 bit list from @buffer in standard codec format.
252 // Returns a new #FlValue of type #FL_VALUE_TYPE_INT32_LIST if successful or
253 // %NULL on error.
254 static FlValue* read_int32_list_value(FlStandardMessageCodec* self,
255  GBytes* buffer,
256  size_t* offset,
257  GError** error) {
258  uint32_t length;
259  if (!fl_standard_message_codec_read_size(self, buffer, offset, &length,
260  error)) {
261  return nullptr;
262  }
263  if (!read_align(buffer, offset, 4, error)) {
264  return nullptr;
265  }
266  if (!check_size(buffer, *offset, sizeof(int32_t) * length, error)) {
267  return nullptr;
268  }
270  reinterpret_cast<const int32_t*>(get_data(buffer, offset)), length);
271  *offset += sizeof(int32_t) * length;
272  return value;
273 }
274 
275 // Reads a signed 64 bit list from @buffer in standard codec format.
276 // Returns a new #FlValue of type #FL_VALUE_TYPE_INT64_LIST if successful or
277 // %NULL on error.
278 static FlValue* read_int64_list_value(FlStandardMessageCodec* self,
279  GBytes* buffer,
280  size_t* offset,
281  GError** error) {
282  uint32_t length;
283  if (!fl_standard_message_codec_read_size(self, buffer, offset, &length,
284  error)) {
285  return nullptr;
286  }
287  if (!read_align(buffer, offset, 8, error)) {
288  return nullptr;
289  }
290  if (!check_size(buffer, *offset, sizeof(int64_t) * length, error)) {
291  return nullptr;
292  }
294  reinterpret_cast<const int64_t*>(get_data(buffer, offset)), length);
295  *offset += sizeof(int64_t) * length;
296  return value;
297 }
298 
299 // Reads a 32 bit floating point number list from @buffer in standard codec
300 // format. Returns a new #FlValue of type #FL_VALUE_TYPE_FLOAT32_LIST if
301 // successful or %NULL on error.
302 static FlValue* read_float32_list_value(FlStandardMessageCodec* self,
303  GBytes* buffer,
304  size_t* offset,
305  GError** error) {
306  uint32_t length;
307  if (!fl_standard_message_codec_read_size(self, buffer, offset, &length,
308  error)) {
309  return nullptr;
310  }
311  if (!read_align(buffer, offset, 4, error)) {
312  return nullptr;
313  }
314  if (!check_size(buffer, *offset, sizeof(float) * length, error)) {
315  return nullptr;
316  }
318  reinterpret_cast<const float*>(get_data(buffer, offset)), length);
319  *offset += sizeof(float) * length;
320  return value;
321 }
322 
323 // Reads a floating point number list from @buffer in standard codec format.
324 // Returns a new #FlValue of type #FL_VALUE_TYPE_FLOAT_LIST if successful or
325 // %NULL on error.
326 static FlValue* read_float64_list_value(FlStandardMessageCodec* self,
327  GBytes* buffer,
328  size_t* offset,
329  GError** error) {
330  uint32_t length;
331  if (!fl_standard_message_codec_read_size(self, buffer, offset, &length,
332  error)) {
333  return nullptr;
334  }
335  if (!read_align(buffer, offset, 8, error)) {
336  return nullptr;
337  }
338  if (!check_size(buffer, *offset, sizeof(double) * length, error)) {
339  return nullptr;
340  }
342  reinterpret_cast<const double*>(get_data(buffer, offset)), length);
343  *offset += sizeof(double) * length;
344  return value;
345 }
346 
347 // Reads a list from @buffer in standard codec format.
348 // Returns a new #FlValue of type #FL_VALUE_TYPE_LIST if successful or %NULL on
349 // error.
350 static FlValue* read_list_value(FlStandardMessageCodec* self,
351  GBytes* buffer,
352  size_t* offset,
353  GError** error) {
354  uint32_t length;
355  if (!fl_standard_message_codec_read_size(self, buffer, offset, &length,
356  error)) {
357  return nullptr;
358  }
359 
360  g_autoptr(FlValue) list = fl_value_new_list();
361  for (size_t i = 0; i < length; i++) {
362  g_autoptr(FlValue) child =
364  if (child == nullptr) {
365  return nullptr;
366  }
367  fl_value_append(list, child);
368  }
369 
370  return fl_value_ref(list);
371 }
372 
373 // Reads a map from @buffer in standard codec format.
374 // Returns a new #FlValue of type #FL_VALUE_TYPE_MAP if successful or %NULL on
375 // error.
376 static FlValue* read_map_value(FlStandardMessageCodec* self,
377  GBytes* buffer,
378  size_t* offset,
379  GError** error) {
380  uint32_t length;
381  if (!fl_standard_message_codec_read_size(self, buffer, offset, &length,
382  error)) {
383  return nullptr;
384  }
385 
386  g_autoptr(FlValue) map = fl_value_new_map();
387  for (size_t i = 0; i < length; i++) {
388  g_autoptr(FlValue) key =
390  if (key == nullptr) {
391  return nullptr;
392  }
393  g_autoptr(FlValue) value =
395  if (value == nullptr) {
396  return nullptr;
397  }
398  fl_value_set(map, key, value);
399  }
400 
401  return fl_value_ref(map);
402 }
403 
404 // Implements FlMessageCodec::encode_message.
405 static GBytes* fl_standard_message_codec_encode_message(FlMessageCodec* codec,
406  FlValue* message,
407  GError** error) {
408  FlStandardMessageCodec* self =
409  reinterpret_cast<FlStandardMessageCodec*>(codec);
410 
411  g_autoptr(GByteArray) buffer = g_byte_array_new();
412  if (!fl_standard_message_codec_write_value(self, buffer, message, error)) {
413  return nullptr;
414  }
415  return g_byte_array_free_to_bytes(
416  static_cast<GByteArray*>(g_steal_pointer(&buffer)));
417 }
418 
419 // Implements FlMessageCodec::decode_message.
420 static FlValue* fl_standard_message_codec_decode_message(FlMessageCodec* codec,
421  GBytes* message,
422  GError** error) {
423  if (g_bytes_get_size(message) == 0) {
424  return fl_value_new_null();
425  }
426 
427  FlStandardMessageCodec* self =
428  reinterpret_cast<FlStandardMessageCodec*>(codec);
429 
430  size_t offset = 0;
431  g_autoptr(FlValue) value =
432  fl_standard_message_codec_read_value(self, message, &offset, error);
433  if (value == nullptr) {
434  return nullptr;
435  }
436 
437  if (offset != g_bytes_get_size(message)) {
438  g_set_error(error, FL_MESSAGE_CODEC_ERROR,
440  "Unused %zi bytes after standard message",
441  g_bytes_get_size(message) - offset);
442  return nullptr;
443  }
444 
445  return fl_value_ref(value);
446 }
447 
449  FlStandardMessageCodecClass* klass) {
450  FL_MESSAGE_CODEC_CLASS(klass)->encode_message =
452  FL_MESSAGE_CODEC_CLASS(klass)->decode_message =
454 }
455 
456 static void fl_standard_message_codec_init(FlStandardMessageCodec* self) {}
457 
458 G_MODULE_EXPORT FlStandardMessageCodec* fl_standard_message_codec_new() {
459  return static_cast<FlStandardMessageCodec*>(
460  g_object_new(fl_standard_message_codec_get_type(), nullptr));
461 }
462 
463 void fl_standard_message_codec_write_size(FlStandardMessageCodec* codec,
464  GByteArray* buffer,
465  uint32_t size) {
466  if (size < 254) {
467  write_uint8(buffer, size);
468  } else if (size <= 0xffff) {
469  write_uint8(buffer, 254);
470  write_uint16(buffer, size);
471  } else {
472  write_uint8(buffer, 255);
473  write_uint32(buffer, size);
474  }
475 }
476 
477 gboolean fl_standard_message_codec_read_size(FlStandardMessageCodec* codec,
478  GBytes* buffer,
479  size_t* offset,
480  uint32_t* value,
481  GError** error) {
482  uint8_t value8;
483  if (!read_uint8(buffer, offset, &value8, error)) {
484  return FALSE;
485  }
486 
487  if (value8 == 255) {
488  if (!read_uint32(buffer, offset, value, error)) {
489  return FALSE;
490  }
491  } else if (value8 == 254) {
492  uint16_t value16;
493  if (!read_uint16(buffer, offset, &value16, error)) {
494  return FALSE;
495  }
496  *value = value16;
497  } else {
498  *value = value8;
499  }
500 
501  return TRUE;
502 }
503 
504 gboolean fl_standard_message_codec_write_value(FlStandardMessageCodec* self,
505  GByteArray* buffer,
506  FlValue* value,
507  GError** error) {
508  if (value == nullptr) {
509  write_uint8(buffer, kValueNull);
510  return TRUE;
511  }
512 
513  switch (fl_value_get_type(value)) {
514  case FL_VALUE_TYPE_NULL:
515  write_uint8(buffer, kValueNull);
516  return TRUE;
517  case FL_VALUE_TYPE_BOOL:
518  if (fl_value_get_bool(value)) {
519  write_uint8(buffer, kValueTrue);
520  } else {
521  write_uint8(buffer, kValueFalse);
522  }
523  return TRUE;
524  case FL_VALUE_TYPE_INT: {
525  int64_t v = fl_value_get_int(value);
526  if (v >= INT32_MIN && v <= INT32_MAX) {
527  write_uint8(buffer, kValueInt32);
528  write_int32(buffer, v);
529  } else {
530  write_uint8(buffer, kValueInt64);
531  write_int64(buffer, v);
532  }
533  return TRUE;
534  }
535  case FL_VALUE_TYPE_FLOAT:
536  write_uint8(buffer, kValueFloat64);
537  write_align(buffer, 8);
539  return TRUE;
540  case FL_VALUE_TYPE_STRING: {
541  write_uint8(buffer, kValueString);
542  const char* text = fl_value_get_string(value);
543  size_t length = strlen(text);
545  g_byte_array_append(buffer, reinterpret_cast<const uint8_t*>(text),
546  length);
547  return TRUE;
548  }
550  write_uint8(buffer, kValueUint8List);
551  size_t length = fl_value_get_length(value);
553  g_byte_array_append(buffer, fl_value_get_uint8_list(value),
554  sizeof(uint8_t) * length);
555  return TRUE;
556  }
558  write_uint8(buffer, kValueInt32List);
559  size_t length = fl_value_get_length(value);
561  write_align(buffer, 4);
562  g_byte_array_append(
563  buffer,
564  reinterpret_cast<const uint8_t*>(fl_value_get_int32_list(value)),
565  sizeof(int32_t) * length);
566  return TRUE;
567  }
569  write_uint8(buffer, kValueInt64List);
570  size_t length = fl_value_get_length(value);
572  write_align(buffer, 8);
573  g_byte_array_append(
574  buffer,
575  reinterpret_cast<const uint8_t*>(fl_value_get_int64_list(value)),
576  sizeof(int64_t) * length);
577  return TRUE;
578  }
580  write_uint8(buffer, kValueFloat32List);
581  size_t length = fl_value_get_length(value);
583  write_align(buffer, 4);
584  g_byte_array_append(
585  buffer,
586  reinterpret_cast<const uint8_t*>(fl_value_get_float32_list(value)),
587  sizeof(float) * length);
588  return TRUE;
589  }
591  write_uint8(buffer, kValueFloat64List);
592  size_t length = fl_value_get_length(value);
594  write_align(buffer, 8);
595  g_byte_array_append(
596  buffer,
597  reinterpret_cast<const uint8_t*>(fl_value_get_float_list(value)),
598  sizeof(double) * length);
599  return TRUE;
600  }
601  case FL_VALUE_TYPE_LIST:
602  write_uint8(buffer, kValueList);
605  for (size_t i = 0; i < fl_value_get_length(value); i++) {
607  self, buffer, fl_value_get_list_value(value, i), error)) {
608  return FALSE;
609  }
610  }
611  return TRUE;
612  case FL_VALUE_TYPE_MAP:
613  write_uint8(buffer, kValueMap);
616  for (size_t i = 0; i < fl_value_get_length(value); i++) {
618  self, buffer, fl_value_get_map_key(value, i), error) ||
620  self, buffer, fl_value_get_map_value(value, i), error)) {
621  return FALSE;
622  }
623  }
624  return TRUE;
625  }
626 
627  g_set_error(error, FL_MESSAGE_CODEC_ERROR,
629  "Unexpected FlValue type %d", fl_value_get_type(value));
630  return FALSE;
631 }
632 
633 FlValue* fl_standard_message_codec_read_value(FlStandardMessageCodec* self,
634  GBytes* buffer,
635  size_t* offset,
636  GError** error) {
637  uint8_t type;
638  if (!read_uint8(buffer, offset, &type, error)) {
639  return nullptr;
640  }
641 
642  g_autoptr(FlValue) value = nullptr;
643  if (type == kValueNull) {
644  return fl_value_new_null();
645  } else if (type == kValueTrue) {
646  return fl_value_new_bool(TRUE);
647  } else if (type == kValueFalse) {
648  return fl_value_new_bool(FALSE);
649  } else if (type == kValueInt32) {
650  value = read_int32_value(buffer, offset, error);
651  } else if (type == kValueInt64) {
652  value = read_int64_value(buffer, offset, error);
653  } else if (type == kValueFloat64) {
654  value = read_float64_value(buffer, offset, error);
655  } else if (type == kValueString) {
656  value = read_string_value(self, buffer, offset, error);
657  } else if (type == kValueUint8List) {
658  value = read_uint8_list_value(self, buffer, offset, error);
659  } else if (type == kValueInt32List) {
660  value = read_int32_list_value(self, buffer, offset, error);
661  } else if (type == kValueInt64List) {
662  value = read_int64_list_value(self, buffer, offset, error);
663  } else if (type == kValueFloat32List) {
664  value = read_float32_list_value(self, buffer, offset, error);
665  } else if (type == kValueFloat64List) {
666  value = read_float64_list_value(self, buffer, offset, error);
667  } else if (type == kValueList) {
668  value = read_list_value(self, buffer, offset, error);
669  } else if (type == kValueMap) {
670  value = read_map_value(self, buffer, offset, error);
671  } else {
672  g_set_error(error, FL_MESSAGE_CODEC_ERROR,
674  "Unexpected standard codec type %02x", type);
675  return nullptr;
676  }
677 
678  return value == nullptr ? nullptr : fl_value_ref(value);
679 }
G_DEFINE_TYPE
G_DEFINE_TYPE(FlStandardMessageCodec, fl_standard_message_codec, fl_message_codec_get_type()) static void write_uint8(GByteArray *buffer
read_list_value
static FlValue * read_list_value(FlStandardMessageCodec *self, GBytes *buffer, size_t *offset, GError **error)
Definition: fl_standard_message_codec.cc:350
read_uint16
static gboolean read_uint16(GBytes *buffer, size_t *offset, uint16_t *value, GError **error)
Definition: fl_standard_message_codec.cc:131
kValueList
static constexpr int kValueList
Definition: fl_standard_message_codec.cc:27
fl_value_get_int32_list
const G_MODULE_EXPORT int32_t * fl_value_get_int32_list(FlValue *self)
Definition: fl_value.cc:656
FL_VALUE_TYPE_UINT8_LIST
@ FL_VALUE_TYPE_UINT8_LIST
Definition: fl_value.h:65
fl_value_new_string_sized
G_MODULE_EXPORT FlValue * fl_value_new_string_sized(const gchar *value, size_t value_length)
Definition: fl_value.cc:272
FL_VALUE_TYPE_MAP
@ FL_VALUE_TYPE_MAP
Definition: fl_value.h:70
fl_standard_message_codec_read_value
FlValue * fl_standard_message_codec_read_value(FlStandardMessageCodec *self, GBytes *buffer, size_t *offset, GError **error)
Definition: fl_standard_message_codec.cc:633
fl_standard_message_codec_new
G_MODULE_EXPORT FlStandardMessageCodec * fl_standard_message_codec_new()
Definition: fl_standard_message_codec.cc:458
fl_standard_message_codec_private.h
kValueUint8List
static constexpr int kValueUint8List
Definition: fl_standard_message_codec.cc:23
fl_standard_message_codec_encode_message
static GBytes * fl_standard_message_codec_encode_message(FlMessageCodec *codec, FlValue *message, GError **error)
Definition: fl_standard_message_codec.cc:405
read_int32_value
static FlValue * read_int32_value(GBytes *buffer, size_t *offset, GError **error)
Definition: fl_standard_message_codec.cc:162
kValueNull
static constexpr int kValueNull
Definition: fl_standard_message_codec.cc:16
kValueInt64List
static constexpr int kValueInt64List
Definition: fl_standard_message_codec.cc:25
fl_value_new_list
G_MODULE_EXPORT FlValue * fl_value_new_list()
Definition: fl_value.cc:338
fl_value_new_float32_list
G_MODULE_EXPORT FlValue * fl_value_new_float32_list(const float *data, size_t data_length)
Definition: fl_value.cc:318
fl_value_get_float_list
const G_MODULE_EXPORT double * fl_value_get_float_list(FlValue *self)
Definition: fl_value.cc:677
kValueInt32List
static constexpr int kValueInt32List
Definition: fl_standard_message_codec.cc:24
kValueInt64
static constexpr int kValueInt64
Definition: fl_standard_message_codec.cc:20
fl_value_new_bool
G_MODULE_EXPORT FlValue * fl_value_new_bool(bool value)
Definition: fl_value.cc:244
FL_MESSAGE_CODEC_ERROR_ADDITIONAL_DATA
@ FL_MESSAGE_CODEC_ERROR_ADDITIONAL_DATA
Definition: fl_message_codec.h:35
FlValue
typedefG_BEGIN_DECLS struct _FlValue FlValue
Definition: fl_value.h:40
kValueInt32
static constexpr int kValueInt32
Definition: fl_standard_message_codec.cc:19
kValueFloat64List
static constexpr int kValueFloat64List
Definition: fl_standard_message_codec.cc:26
write_float64
static void write_float64(GByteArray *buffer, double value)
Definition: fl_standard_message_codec.cc:65
kValueTrue
static constexpr int kValueTrue
Definition: fl_standard_message_codec.cc:17
fl_value_new_null
G_MODULE_EXPORT FlValue * fl_value_new_null()
Definition: fl_value.cc:240
FL_VALUE_TYPE_LIST
@ FL_VALUE_TYPE_LIST
Definition: fl_value.h:69
read_string_value
static FlValue * read_string_value(FlStandardMessageCodec *self, GBytes *buffer, size_t *offset, GError **error)
Definition: fl_standard_message_codec.cc:213
fl_value_get_bool
G_MODULE_EXPORT bool fl_value_get_bool(FlValue *self)
Definition: fl_value.cc:621
fl_value_get_uint8_list
const G_MODULE_EXPORT uint8_t * fl_value_get_uint8_list(FlValue *self)
Definition: fl_value.cc:649
fl_value_set
G_MODULE_EXPORT void fl_value_set(FlValue *self, FlValue *key, FlValue *value)
Definition: fl_value.cc:569
write_int64
static void write_int64(GByteArray *buffer, int64_t value)
Definition: fl_standard_message_codec.cc:60
fl_value_new_int
G_MODULE_EXPORT FlValue * fl_value_new_int(int64_t value)
Definition: fl_value.cc:251
fl_value_get_string
const G_MODULE_EXPORT gchar * fl_value_get_string(FlValue *self)
Definition: fl_value.cc:642
read_float64_value
static FlValue * read_float64_value(GBytes *buffer, size_t *offset, GError **error)
Definition: fl_standard_message_codec.cc:194
fl_value_get_float32_list
const G_MODULE_EXPORT float * fl_value_get_float32_list(FlValue *self)
Definition: fl_value.cc:670
read_map_value
static FlValue * read_map_value(FlStandardMessageCodec *self, GBytes *buffer, size_t *offset, GError **error)
Definition: fl_standard_message_codec.cc:376
FL_VALUE_TYPE_NULL
@ FL_VALUE_TYPE_NULL
Definition: fl_value.h:60
read_align
static gboolean read_align(GBytes *buffer, size_t *offset, size_t align, GError **error)
Definition: fl_standard_message_codec.cc:91
read_int32_list_value
static FlValue * read_int32_list_value(FlStandardMessageCodec *self, GBytes *buffer, size_t *offset, GError **error)
Definition: fl_standard_message_codec.cc:254
fl_value_get_int
G_MODULE_EXPORT int64_t fl_value_get_int(FlValue *self)
Definition: fl_value.cc:628
write_int32
static void write_int32(GByteArray *buffer, int32_t value)
Definition: fl_standard_message_codec.cc:55
read_uint8_list_value
static FlValue * read_uint8_list_value(FlStandardMessageCodec *self, GBytes *buffer, size_t *offset, GError **error)
Definition: fl_standard_message_codec.cc:234
fl_standard_message_codec_write_size
void fl_standard_message_codec_write_size(FlStandardMessageCodec *codec, GByteArray *buffer, uint32_t size)
Definition: fl_standard_message_codec.cc:463
fl_value_ref
G_MODULE_EXPORT FlValue * fl_value_ref(FlValue *self)
Definition: fl_value.cc:363
fl_value_new_map
G_MODULE_EXPORT FlValue * fl_value_new_map()
Definition: fl_value.cc:355
fl_value_get_type
G_MODULE_EXPORT FlValueType fl_value_get_type(FlValue *self)
Definition: fl_value.cc:428
write_uint16
static void write_uint16(GByteArray *buffer, uint16_t value)
Definition: fl_standard_message_codec.cc:45
fl_value_get_list_value
G_MODULE_EXPORT FlValue * fl_value_get_list_value(FlValue *self, size_t index)
Definition: fl_value.cc:735
read_int64_value
static FlValue * read_int64_value(GBytes *buffer, size_t *offset, GError **error)
Definition: fl_standard_message_codec.cc:178
FL_VALUE_TYPE_FLOAT32_LIST
@ FL_VALUE_TYPE_FLOAT32_LIST
Definition: fl_value.h:71
FL_VALUE_TYPE_STRING
@ FL_VALUE_TYPE_STRING
Definition: fl_value.h:64
fl_standard_message_codec_read_size
gboolean fl_standard_message_codec_read_size(FlStandardMessageCodec *codec, GBytes *buffer, size_t *offset, uint32_t *value, GError **error)
Definition: fl_standard_message_codec.cc:477
read_float32_list_value
static FlValue * read_float32_list_value(FlStandardMessageCodec *self, GBytes *buffer, size_t *offset, GError **error)
Definition: fl_standard_message_codec.cc:302
fl_value_new_float_list
G_MODULE_EXPORT FlValue * fl_value_new_float_list(const double *data, size_t data_length)
Definition: fl_value.cc:328
kValueFalse
static constexpr int kValueFalse
Definition: fl_standard_message_codec.cc:18
fl_standard_message_codec_decode_message
static FlValue * fl_standard_message_codec_decode_message(FlMessageCodec *codec, GBytes *message, GError **error)
Definition: fl_standard_message_codec.cc:420
TRUE
return TRUE
Definition: fl_pixel_buffer_texture_test.cc:53
check_size
static gboolean check_size(GBytes *buffer, size_t offset, size_t required, GError **error)
Definition: fl_standard_message_codec.cc:78
fl_value_new_int32_list
G_MODULE_EXPORT FlValue * fl_value_new_int32_list(const int32_t *data, size_t data_length)
Definition: fl_value.cc:298
fl_value_get_float
G_MODULE_EXPORT double fl_value_get_float(FlValue *self)
Definition: fl_value.cc:635
fl_value_get_length
G_MODULE_EXPORT size_t fl_value_get_length(FlValue *self)
Definition: fl_value.cc:684
FL_VALUE_TYPE_INT64_LIST
@ FL_VALUE_TYPE_INT64_LIST
Definition: fl_value.h:67
kValueFloat64
static constexpr int kValueFloat64
Definition: fl_standard_message_codec.cc:21
FL_VALUE_TYPE_INT
@ FL_VALUE_TYPE_INT
Definition: fl_value.h:62
fl_value_new_int64_list
G_MODULE_EXPORT FlValue * fl_value_new_int64_list(const int64_t *data, size_t data_length)
Definition: fl_value.cc:308
get_data
static const uint8_t * get_data(GBytes *buffer, size_t *offset)
Definition: fl_standard_message_codec.cc:109
fl_standard_message_codec_class_init
static void fl_standard_message_codec_class_init(FlStandardMessageCodecClass *klass)
Definition: fl_standard_message_codec.cc:448
FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA
@ FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA
Definition: fl_message_codec.h:34
error
const uint8_t uint32_t uint32_t GError ** error
Definition: fl_pixel_buffer_texture_test.cc:40
kValueMap
static constexpr int kValueMap
Definition: fl_standard_message_codec.cc:28
FL_VALUE_TYPE_FLOAT_LIST
@ FL_VALUE_TYPE_FLOAT_LIST
Definition: fl_value.h:68
fl_standard_message_codec_init
static void fl_standard_message_codec_init(FlStandardMessageCodec *self)
Definition: fl_standard_message_codec.cc:456
read_uint32
static gboolean read_uint32(GBytes *buffer, size_t *offset, uint32_t *value, GError **error)
Definition: fl_standard_message_codec.cc:146
fl_value_new_uint8_list
G_MODULE_EXPORT FlValue * fl_value_new_uint8_list(const uint8_t *data, size_t data_length)
Definition: fl_value.cc:281
fl_value_append
G_MODULE_EXPORT void fl_value_append(FlValue *self, FlValue *value)
Definition: fl_value.cc:552
buffer
static const uint8_t buffer[]
Definition: fl_pixel_buffer_texture_test.cc:44
kValueFloat32List
static constexpr int kValueFloat32List
Definition: fl_standard_message_codec.cc:29
FL_VALUE_TYPE_FLOAT
@ FL_VALUE_TYPE_FLOAT
Definition: fl_value.h:63
kValueString
static constexpr int kValueString
Definition: fl_standard_message_codec.cc:22
FL_VALUE_TYPE_INT32_LIST
@ FL_VALUE_TYPE_INT32_LIST
Definition: fl_value.h:66
write_align
static void write_align(GByteArray *buffer, guint align)
Definition: fl_standard_message_codec.cc:71
FL_MESSAGE_CODEC_ERROR_UNSUPPORTED_TYPE
@ FL_MESSAGE_CODEC_ERROR_UNSUPPORTED_TYPE
Definition: fl_message_codec.h:36
fl_value_new_float
G_MODULE_EXPORT FlValue * fl_value_new_float(double value)
Definition: fl_value.cc:258
_FlStandardMessageCodec
Definition: fl_standard_message_codec.cc:31
read_float64_list_value
static FlValue * read_float64_list_value(FlStandardMessageCodec *self, GBytes *buffer, size_t *offset, GError **error)
Definition: fl_standard_message_codec.cc:326
fl_standard_message_codec.h
fl_value_get_map_key
G_MODULE_EXPORT FlValue * fl_value_get_map_key(FlValue *self, size_t index)
Definition: fl_value.cc:743
read_uint8
static gboolean read_uint8(GBytes *buffer, size_t *offset, uint8_t *value, GError **error)
Definition: fl_standard_message_codec.cc:116
write_uint32
static void write_uint32(GByteArray *buffer, uint32_t value)
Definition: fl_standard_message_codec.cc:50
fl_value_get_int64_list
const G_MODULE_EXPORT int64_t * fl_value_get_int64_list(FlValue *self)
Definition: fl_value.cc:663
FL_VALUE_TYPE_BOOL
@ FL_VALUE_TYPE_BOOL
Definition: fl_value.h:61
value
uint8_t value
Definition: fl_standard_message_codec.cc:41
fl_standard_message_codec_write_value
gboolean fl_standard_message_codec_write_value(FlStandardMessageCodec *self, GByteArray *buffer, FlValue *value, GError **error)
Definition: fl_standard_message_codec.cc:504
fl_value_get_map_value
G_MODULE_EXPORT FlValue * fl_value_get_map_value(FlValue *self, size_t index)
Definition: fl_value.cc:751
read_int64_list_value
static FlValue * read_int64_list_value(FlStandardMessageCodec *self, GBytes *buffer, size_t *offset, GError **error)
Definition: fl_standard_message_codec.cc:278
_FlStandardMessageCodec::parent_instance
FlMessageCodec parent_instance
Definition: fl_standard_message_codec.cc:32
FL_MESSAGE_CODEC_ERROR
#define FL_MESSAGE_CODEC_ERROR
Definition: fl_message_codec.h:30