#include "flutter/shell/platform/linux/public/flutter_linux/fl_standard_message_codec.h"
#include <gmodule.h>
#include <cstring>

Functions
	G_DEFINE_TYPE (FlStandardMessageCodec, fl_standard_message_codec, fl_message_codec_get_type()) static void write_uint8(GByteArray *buffer

static void	write_uint16 (GByteArray *buffer, uint16_t value)

static void	write_uint32 (GByteArray *buffer, uint32_t value)

static void	write_int32 (GByteArray *buffer, int32_t value)

static void	write_int64 (GByteArray *buffer, int64_t value)

static void	write_float64 (GByteArray *buffer, double value)

static void	write_align (GByteArray *buffer, guint align)

static gboolean	check_size (GBytes buffer, size_t offset, size_t required, GError *error)

static gboolean	read_align (GBytes buffer, size_t offset, size_t align, GError **error)

static const uint8_t *	get_data (GBytes buffer, size_t offset)

static gboolean	read_uint8 (GBytes buffer, size_t offset, uint8_t value, GError *error)

static gboolean	read_uint16 (GBytes buffer, size_t offset, uint16_t value, GError *error)

static gboolean	read_uint32 (GBytes buffer, size_t offset, uint32_t value, GError *error)

static FlValue *	read_int32_value (GBytes buffer, size_t offset, GError **error)

static FlValue *	read_int64_value (GBytes buffer, size_t offset, GError **error)

static FlValue *	read_float64_value (GBytes buffer, size_t offset, GError **error)

static FlValue *	read_string_value (FlStandardMessageCodec self, GBytes buffer, size_t offset, GError *error)

static FlValue *	read_uint8_list_value (FlStandardMessageCodec self, GBytes buffer, size_t offset, GError *error)

static FlValue *	read_int32_list_value (FlStandardMessageCodec self, GBytes buffer, size_t offset, GError *error)

static FlValue *	read_int64_list_value (FlStandardMessageCodec self, GBytes buffer, size_t offset, GError *error)

static FlValue *	read_float32_list_value (FlStandardMessageCodec self, GBytes buffer, size_t offset, GError *error)

static FlValue *	read_float64_list_value (FlStandardMessageCodec self, GBytes buffer, size_t offset, GError *error)

static FlValue *	read_list_value (FlStandardMessageCodec self, GBytes buffer, size_t offset, GError *error)

static FlValue *	read_map_value (FlStandardMessageCodec self, GBytes buffer, size_t offset, GError *error)

static GBytes *	fl_standard_message_codec_encode_message (FlMessageCodec codec, FlValue message, GError **error)

static FlValue *	fl_standard_message_codec_decode_message (FlMessageCodec codec, GBytes message, GError **error)

static gboolean	fl_standard_message_codec_real_write_value (FlStandardMessageCodec self, GByteArray buffer, FlValue value, GError *error)

static FlValue *	fl_standard_message_codec_read_value_of_type (FlStandardMessageCodec self, GBytes buffer, size_t offset, int type, GError *error)

static void	fl_standard_message_codec_class_init (FlStandardMessageCodecClass *klass)

static void	fl_standard_message_codec_init (FlStandardMessageCodec *self)

G_MODULE_EXPORT FlStandardMessageCodec *	fl_standard_message_codec_new ()

G_MODULE_EXPORT void	fl_standard_message_codec_write_size (FlStandardMessageCodec codec, GByteArray buffer, uint32_t size)

G_MODULE_EXPORT gboolean	fl_standard_message_codec_read_size (FlStandardMessageCodec codec, GBytes buffer, size_t offset, uint32_t value, GError **error)

G_MODULE_EXPORT gboolean	fl_standard_message_codec_write_value (FlStandardMessageCodec self, GByteArray buffer, FlValue value, GError *error)

G_MODULE_EXPORT FlValue *	fl_standard_message_codec_read_value (FlStandardMessageCodec self, GBytes buffer, size_t offset, GError *error)

Variables
static constexpr int	kValueNull = 0

static constexpr int	kValueTrue = 1

static constexpr int	kValueFalse = 2

static constexpr int	kValueInt32 = 3

static constexpr int	kValueInt64 = 4

static constexpr int	kValueFloat64 = 6

static constexpr int	kValueString = 7

static constexpr int	kValueUint8List = 8

static constexpr int	kValueInt32List = 9

static constexpr int	kValueInt64List = 10

static constexpr int	kValueFloat64List = 11

static constexpr int	kValueList = 12

static constexpr int	kValueMap = 13

static constexpr int	kValueFloat32List = 14

uint8_t	value

Function Documentation

◆ check_size()

static gboolean check_size	(	GBytes *	buffer,
		size_t	offset,
		size_t	required,
		GError **	error
	)

static

Definition at line 73 of file fl_standard_message_codec.cc.

                                           {
  if (offset + required > g_bytes_get_size(buffer)) {
    g_set_error(error, FL_MESSAGE_CODEC_ERROR,
                FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA, "Unexpected end of data");
    return FALSE;
  }
  return TRUE;
}

References error, FL_MESSAGE_CODEC_ERROR, FL_MESSAGE_CODEC_ERROR_OUT_OF_DATA, and TRUE.

Referenced by read_align(), read_float32_list_value(), read_float64_list_value(), read_float64_value(), read_int32_list_value(), read_int32_value(), read_int64_list_value(), read_int64_value(), read_string_value(), read_uint16(), read_uint32(), read_uint8(), and read_uint8_list_value().

◆ fl_standard_message_codec_class_init()

static void fl_standard_message_codec_class_init ( FlStandardMessageCodecClass * klass )

static

Definition at line 625 of file fl_standard_message_codec.cc.

                                        {
  FL_MESSAGE_CODEC_CLASS(klass)->encode_message =
      fl_standard_message_codec_encode_message;
  FL_MESSAGE_CODEC_CLASS(klass)->decode_message =
      fl_standard_message_codec_decode_message;
  klass->write_value = fl_standard_message_codec_real_write_value;
  klass->read_value_of_type = fl_standard_message_codec_read_value_of_type;
}

References fl_standard_message_codec_decode_message(), fl_standard_message_codec_encode_message(), fl_standard_message_codec_read_value_of_type(), and fl_standard_message_codec_real_write_value().

◆ fl_standard_message_codec_decode_message()

static FlValue * fl_standard_message_codec_decode_message	(	FlMessageCodec *	codec,
		GBytes *	message,
		GError **	error
	)

static

Definition at line 415 of file fl_standard_message_codec.cc.

                                                                         {
  if (g_bytes_get_size(message) == 0) {
    return fl_value_new_null();
  }
 
  FlStandardMessageCodec* self =
      reinterpret_cast<FlStandardMessageCodec*>(codec);
 
  size_t offset = 0;
  g_autoptr(FlValue) value =
      fl_standard_message_codec_read_value(self, message, &offset, error);
  if (value == nullptr) {
    return nullptr;
  }
 
  if (offset != g_bytes_get_size(message)) {
    g_set_error(error, FL_MESSAGE_CODEC_ERROR,
                FL_MESSAGE_CODEC_ERROR_ADDITIONAL_DATA,
                "Unused %zi bytes after standard message",
                g_bytes_get_size(message) - offset);
    return nullptr;
  }
 
  return fl_value_ref(value);
}

References error, FL_MESSAGE_CODEC_ERROR, FL_MESSAGE_CODEC_ERROR_ADDITIONAL_DATA, fl_standard_message_codec_read_value(), fl_value_new_null(), fl_value_ref(), g_autoptr(), message, self, and value.

Referenced by fl_standard_message_codec_class_init().

◆ fl_standard_message_codec_encode_message()

static GBytes * fl_standard_message_codec_encode_message	(	FlMessageCodec *	codec,
		FlValue *	message,
		GError **	error
	)

static

Definition at line 400 of file fl_standard_message_codec.cc.

                                                                        {
  FlStandardMessageCodec* self =
      reinterpret_cast<FlStandardMessageCodec*>(codec);
 
  g_autoptr(GByteArray) buffer = g_byte_array_new();
  if (!fl_standard_message_codec_write_value(self, buffer, message, error)) {
    return nullptr;
  }
  return g_byte_array_free_to_bytes(
      static_cast<GByteArray*>(g_steal_pointer(&buffer)));
}

References error, fl_standard_message_codec_write_value(), g_autoptr(), message, and self.

Referenced by fl_standard_message_codec_class_init().

◆ fl_standard_message_codec_init()

static void fl_standard_message_codec_init ( FlStandardMessageCodec * self )

static

Definition at line 635 of file fl_standard_message_codec.cc.

635{}

◆ fl_standard_message_codec_new()

G_MODULE_EXPORT FlStandardMessageCodec * fl_standard_message_codec_new ( )

Definition at line 637 of file fl_standard_message_codec.cc.

                                                                        {
  return static_cast<FlStandardMessageCodec*>(
      g_object_new(fl_standard_message_codec_get_type(), nullptr));
}

Referenced by decode_error_value(), decode_message(), decode_semantic_data(), encode_message(), fl_accessible_text_field_perform_action(), fl_mock_binary_messenger_send_standard_message(), fl_mock_binary_messenger_set_standard_message_channel(), fl_mock_binary_messenger_standard_message_channel_respond(), fl_standard_method_codec_new(), perform_set_selection_action(), perform_set_text_action(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), and TEST().

◆ fl_standard_message_codec_read_size()

G_MODULE_EXPORT gboolean fl_standard_message_codec_read_size	(	FlStandardMessageCodec *	codec,
		GBytes *	buffer,
		size_t *	offset,
		uint32_t *	value,
		GError **	error
	)

fl_standard_message_codec_read_size: @codec: an #FlStandardMessageCodec. @buffer: buffer to read from. @offset: (inout): read position in @buffer. @value: location to read size. @error: (allow-none): #GError location to store the error occurring, or NULL.

Reads a size field in Flutter Standard encoding.

This method is intended for use by subclasses overriding FlStandardMessageCodec::read_value_of_type.

Returns: TRUE on success.

Definition at line 658 of file fl_standard_message_codec.cc.

                                                    {
  uint8_t value8;
  if (!read_uint8(buffer, offset, &value8, error)) {
    return FALSE;
  }
 
  if (value8 == 255) {
    if (!read_uint32(buffer, offset, value, error)) {
      return FALSE;
    }
  } else if (value8 == 254) {
    uint16_t value16;
    if (!read_uint16(buffer, offset, &value16, error)) {
      return FALSE;
    }
    *value = value16;
  } else {
    *value = value8;
  }
 
  return TRUE;
}

References error, read_uint16(), read_uint32(), read_uint8(), TRUE, and value.

Referenced by read_custom_value(), read_custom_value1(), read_float32_list_value(), read_float64_list_value(), read_int32_list_value(), read_int64_list_value(), read_list_value(), read_map_value(), read_string_value(), and read_uint8_list_value().

◆ fl_standard_message_codec_read_value()

G_MODULE_EXPORT FlValue * fl_standard_message_codec_read_value	(	FlStandardMessageCodec *	codec,
		GBytes *	buffer,
		size_t *	offset,
		GError **	error
	)

fl_standard_message_codec_read_value: @codec: an #FlStandardMessageCodec. @buffer: buffer to read from. @offset: (inout): read position in @buffer. @value: location to read size. @error: (allow-none): #GError location to store the error occurring, or NULL.

Reads an FlValue in Flutter Standard encoding.

This method is intended for use by subclasses overriding FlStandardMessageCodec::read_value_of_type.

Returns: a new FlValue or NULL on error.

Definition at line 694 of file fl_standard_message_codec.cc.

                    {
  uint8_t type;
  if (!read_uint8(buffer, offset, &type, error)) {
    return nullptr;
  }
 
  return FL_STANDARD_MESSAGE_CODEC_GET_CLASS(self)->read_value_of_type(
      self, buffer, offset, type, error);
}

References error, read_uint8(), self, and type.

Referenced by fl_standard_message_codec_decode_message(), fl_standard_method_codec_decode_method_call(), fl_standard_method_codec_decode_response(), read_list_value(), and read_map_value().

◆ fl_standard_message_codec_read_value_of_type()

static FlValue * fl_standard_message_codec_read_value_of_type	(	FlStandardMessageCodec *	self,
		GBytes *	buffer,
		size_t *	offset,
		int	type,
		GError **	error
	)

static

Definition at line 580 of file fl_standard_message_codec.cc.

                    {
  g_autoptr(FlValue) value = nullptr;
  if (type == kValueNull) {
    return fl_value_new_null();
  } else if (type == kValueTrue) {
    return fl_value_new_bool(TRUE);
  } else if (type == kValueFalse) {
    return fl_value_new_bool(FALSE);
  } else if (type == kValueInt32) {
    value = read_int32_value(buffer, offset, error);
  } else if (type == kValueInt64) {
    value = read_int64_value(buffer, offset, error);
  } else if (type == kValueFloat64) {
    value = read_float64_value(buffer, offset, error);
  } else if (type == kValueString) {
    value = read_string_value(self, buffer, offset, error);
  } else if (type == kValueUint8List) {
    value = read_uint8_list_value(self, buffer, offset, error);
  } else if (type == kValueInt32List) {
    value = read_int32_list_value(self, buffer, offset, error);
  } else if (type == kValueInt64List) {
    value = read_int64_list_value(self, buffer, offset, error);
  } else if (type == kValueFloat32List) {
    value = read_float32_list_value(self, buffer, offset, error);
  } else if (type == kValueFloat64List) {
    value = read_float64_list_value(self, buffer, offset, error);
  } else if (type == kValueList) {
    value = read_list_value(self, buffer, offset, error);
  } else if (type == kValueMap) {
    value = read_map_value(self, buffer, offset, error);
  } else {
    g_set_error(error, FL_MESSAGE_CODEC_ERROR,
                FL_MESSAGE_CODEC_ERROR_UNSUPPORTED_TYPE,
                "Unexpected standard codec type %02x", type);
    return nullptr;
  }
 
  return value == nullptr ? nullptr : fl_value_ref(value);
}

References error, FL_MESSAGE_CODEC_ERROR, FL_MESSAGE_CODEC_ERROR_UNSUPPORTED_TYPE, fl_value_new_bool(), fl_value_new_null(), fl_value_ref(), g_autoptr(), kValueFalse, kValueFloat32List, kValueFloat64, kValueFloat64List, kValueInt32, kValueInt32List, kValueInt64, kValueInt64List, kValueList, kValueMap, kValueNull, kValueString, kValueTrue, kValueUint8List, read_float32_list_value(), read_float64_list_value(), read_float64_value(), read_int32_list_value(), read_int32_value(), read_int64_list_value(), read_int64_value(), read_list_value(), read_map_value(), read_string_value(), read_uint8_list_value(), self, TRUE, type, and value.

Referenced by fl_standard_message_codec_class_init().

◆ fl_standard_message_codec_real_write_value()

static gboolean fl_standard_message_codec_real_write_value	(	FlStandardMessageCodec *	self,
		GByteArray *	buffer,
		FlValue *	value,
		GError **	error
	)

static

Definition at line 444 of file fl_standard_message_codec.cc.

                    {
  if (value == nullptr) {
    write_uint8(buffer, kValueNull);
    return TRUE;
  }
 
  switch (fl_value_get_type(value)) {
    case FL_VALUE_TYPE_NULL:
      write_uint8(buffer, kValueNull);
      return TRUE;
    case FL_VALUE_TYPE_BOOL:
      if (fl_value_get_bool(value)) {
        write_uint8(buffer, kValueTrue);
      } else {
        write_uint8(buffer, kValueFalse);
      }
      return TRUE;
    case FL_VALUE_TYPE_INT: {
      int64_t v = fl_value_get_int(value);
      if (v >= INT32_MIN && v <= INT32_MAX) {
        write_uint8(buffer, kValueInt32);
        write_int32(buffer, v);
      } else {
        write_uint8(buffer, kValueInt64);
        write_int64(buffer, v);
      }
      return TRUE;
    }
    case FL_VALUE_TYPE_FLOAT:
      write_uint8(buffer, kValueFloat64);
      write_align(buffer, 8);
      write_float64(buffer, fl_value_get_float(value));
      return TRUE;
    case FL_VALUE_TYPE_STRING: {
      write_uint8(buffer, kValueString);
      const char* text = fl_value_get_string(value);
      size_t length = strlen(text);
      fl_standard_message_codec_write_size(self, buffer, length);
      g_byte_array_append(buffer, reinterpret_cast<const uint8_t*>(text),
                          length);
      return TRUE;
    }
    case FL_VALUE_TYPE_UINT8_LIST: {
      write_uint8(buffer, kValueUint8List);
      size_t length = fl_value_get_length(value);
      fl_standard_message_codec_write_size(self, buffer, length);
      g_byte_array_append(buffer, fl_value_get_uint8_list(value),
                          sizeof(uint8_t) * length);
      return TRUE;
    }
    case FL_VALUE_TYPE_INT32_LIST: {
      write_uint8(buffer, kValueInt32List);
      size_t length = fl_value_get_length(value);
      fl_standard_message_codec_write_size(self, buffer, length);
      write_align(buffer, 4);
      g_byte_array_append(
          buffer,
          reinterpret_cast<const uint8_t*>(fl_value_get_int32_list(value)),
          sizeof(int32_t) * length);
      return TRUE;
    }
    case FL_VALUE_TYPE_INT64_LIST: {
      write_uint8(buffer, kValueInt64List);
      size_t length = fl_value_get_length(value);
      fl_standard_message_codec_write_size(self, buffer, length);
      write_align(buffer, 8);
      g_byte_array_append(
          buffer,
          reinterpret_cast<const uint8_t*>(fl_value_get_int64_list(value)),
          sizeof(int64_t) * length);
      return TRUE;
    }
    case FL_VALUE_TYPE_FLOAT32_LIST: {
      write_uint8(buffer, kValueFloat32List);
      size_t length = fl_value_get_length(value);
      fl_standard_message_codec_write_size(self, buffer, length);
      write_align(buffer, 4);
      g_byte_array_append(
          buffer,
          reinterpret_cast<const uint8_t*>(fl_value_get_float32_list(value)),
          sizeof(float) * length);
      return TRUE;
    }
    case FL_VALUE_TYPE_FLOAT_LIST: {
      write_uint8(buffer, kValueFloat64List);
      size_t length = fl_value_get_length(value);
      fl_standard_message_codec_write_size(self, buffer, length);
      write_align(buffer, 8);
      g_byte_array_append(
          buffer,
          reinterpret_cast<const uint8_t*>(fl_value_get_float_list(value)),
          sizeof(double) * length);
      return TRUE;
    }
    case FL_VALUE_TYPE_LIST:
      write_uint8(buffer, kValueList);
      fl_standard_message_codec_write_size(self, buffer,
                                           fl_value_get_length(value));
      for (size_t i = 0; i < fl_value_get_length(value); i++) {
        if (!fl_standard_message_codec_write_value(
                self, buffer, fl_value_get_list_value(value, i), error)) {
          return FALSE;
        }
      }
      return TRUE;
    case FL_VALUE_TYPE_MAP:
      write_uint8(buffer, kValueMap);
      fl_standard_message_codec_write_size(self, buffer,
                                           fl_value_get_length(value));
      for (size_t i = 0; i < fl_value_get_length(value); i++) {
        if (!fl_standard_message_codec_write_value(
                self, buffer, fl_value_get_map_key(value, i), error) ||
            !fl_standard_message_codec_write_value(
                self, buffer, fl_value_get_map_value(value, i), error)) {
          return FALSE;
        }
      }
      return TRUE;
    case FL_VALUE_TYPE_CUSTOM:
      g_set_error(error, FL_MESSAGE_CODEC_ERROR,
                  FL_MESSAGE_CODEC_ERROR_UNSUPPORTED_TYPE,
                  "Custom value not implemented");
      return FALSE;
  }
 
  g_set_error(error, FL_MESSAGE_CODEC_ERROR,
              FL_MESSAGE_CODEC_ERROR_UNSUPPORTED_TYPE,
              "Unexpected FlValue type %d", fl_value_get_type(value));
  return FALSE;
}

References error, FL_MESSAGE_CODEC_ERROR, FL_MESSAGE_CODEC_ERROR_UNSUPPORTED_TYPE, fl_standard_message_codec_write_size(), fl_standard_message_codec_write_value(), fl_value_get_bool(), fl_value_get_float(), fl_value_get_float32_list(), fl_value_get_float_list(), fl_value_get_int(), fl_value_get_int32_list(), fl_value_get_int64_list(), fl_value_get_length(), fl_value_get_list_value(), fl_value_get_map_key(), fl_value_get_map_value(), fl_value_get_string(), fl_value_get_type(), fl_value_get_uint8_list(), FL_VALUE_TYPE_BOOL, FL_VALUE_TYPE_CUSTOM, FL_VALUE_TYPE_FLOAT, FL_VALUE_TYPE_FLOAT32_LIST, FL_VALUE_TYPE_FLOAT_LIST, FL_VALUE_TYPE_INT, FL_VALUE_TYPE_INT32_LIST, FL_VALUE_TYPE_INT64_LIST, FL_VALUE_TYPE_LIST, FL_VALUE_TYPE_MAP, FL_VALUE_TYPE_NULL, FL_VALUE_TYPE_STRING, FL_VALUE_TYPE_UINT8_LIST, g_byte_array_append(), i, INT32_MAX, INT32_MIN, kValueFalse, kValueFloat32List, kValueFloat64, kValueFloat64List, kValueInt32, kValueInt32List, kValueInt64, kValueInt64List, kValueList, kValueMap, kValueNull, kValueString, kValueTrue, kValueUint8List, length, self, text, TRUE, value, write_align(), write_float64(), write_int32(), and write_int64().

Referenced by fl_standard_message_codec_class_init().

◆ fl_standard_message_codec_write_size()

G_MODULE_EXPORT void fl_standard_message_codec_write_size	(	FlStandardMessageCodec *	codec,
		GByteArray *	buffer,
		uint32_t	size
	)

fl_standard_message_codec_write_size: @codec: an #FlStandardMessageCodec. @buffer: buffer to write into. @size: size value to write.

Writes a size field in Flutter Standard encoding.

Definition at line 642 of file fl_standard_message_codec.cc.

                   {
  if (size < 254) {
    write_uint8(buffer, size);
  } else if (size <= 0xffff) {
    write_uint8(buffer, 254);
    write_uint16(buffer, size);
  } else {
    write_uint8(buffer, 255);
    write_uint32(buffer, size);
  }
}

References write_uint16(), and write_uint32().

Referenced by fl_standard_message_codec_real_write_value().

◆ fl_standard_message_codec_write_value()

G_MODULE_EXPORT gboolean fl_standard_message_codec_write_value	(	FlStandardMessageCodec *	codec,
		GByteArray *	buffer,
		FlValue *	value,
		GError **	error
	)

fl_standard_message_codec_write_value: @codec: an #FlStandardMessageCodec. @buffer: buffer to write into. @value: (allow-none): value to write. @error: (allow-none): #GError location to store the error occurring, or NULL.

Writes an FlValue in Flutter Standard encoding.

This method is intended for use by subclasses overriding FlStandardMessageCodec::write_value.

Returns: TRUE on success.

Definition at line 686 of file fl_standard_message_codec.cc.

                                                      {
  return FL_STANDARD_MESSAGE_CODEC_GET_CLASS(self)->write_value(self, buffer,
                                                                value, error);
}

References error, self, and value.

Referenced by fl_standard_message_codec_encode_message(), fl_standard_message_codec_real_write_value(), fl_standard_method_codec_encode_error_envelope(), fl_standard_method_codec_encode_method_call(), and fl_standard_method_codec_encode_success_envelope().

◆ G_DEFINE_TYPE()

G_DEFINE_TYPE	(	FlStandardMessageCodec	,
		fl_standard_message_codec	,
		fl_message_codec_get_type()
	)

◆ get_data()

static const uint8_t * get_data	(	GBytes *	buffer,
		size_t *	offset
	)

static

Definition at line 104 of file fl_standard_message_codec.cc.

                                                               {
  return static_cast<const uint8_t*>(g_bytes_get_data(buffer, nullptr)) +
         *offset;
}

Referenced by read_float32_list_value(), read_float64_list_value(), read_float64_value(), read_int32_list_value(), read_int32_value(), read_int64_list_value(), read_int64_value(), read_string_value(), read_uint16(), read_uint32(), read_uint8(), and read_uint8_list_value().

◆ read_align()

static gboolean read_align	(	GBytes *	buffer,
		size_t *	offset,
		size_t	align,
		GError **	error
	)

static

Definition at line 86 of file fl_standard_message_codec.cc.

                                           {
  if ((*offset) % align == 0) {
    return TRUE;
  }
 
  size_t required = align - (*offset) % align;
  if (!check_size(buffer, *offset, required, error)) {
    return FALSE;
  }
 
  (*offset) += required;
  return TRUE;
}

References check_size(), error, and TRUE.

Referenced by read_float32_list_value(), read_float64_list_value(), read_float64_value(), read_int32_list_value(), and read_int64_list_value().

◆ read_float32_list_value()

static FlValue * read_float32_list_value	(	FlStandardMessageCodec *	self,
		GBytes *	buffer,
		size_t *	offset,
		GError **	error
	)

static

Definition at line 297 of file fl_standard_message_codec.cc.

                                                        {
  uint32_t length;
  if (!fl_standard_message_codec_read_size(self, buffer, offset, &length,
                                           error)) {
    return nullptr;
  }
  if (!read_align(buffer, offset, 4, error)) {
    return nullptr;
  }
  if (!check_size(buffer, *offset, sizeof(float) * length, error)) {
    return nullptr;
  }
  FlValue* value = fl_value_new_float32_list(
      reinterpret_cast<const float*>(get_data(buffer, offset)), length);
  *offset += sizeof(float) * length;
  return value;
}

References check_size(), error, fl_standard_message_codec_read_size(), fl_value_new_float32_list(), get_data(), length, read_align(), self, and value.

Referenced by fl_standard_message_codec_read_value_of_type().

◆ read_float64_list_value()

static FlValue * read_float64_list_value	(	FlStandardMessageCodec *	self,
		GBytes *	buffer,
		size_t *	offset,
		GError **	error
	)

static

Definition at line 321 of file fl_standard_message_codec.cc.

                                                        {
  uint32_t length;
  if (!fl_standard_message_codec_read_size(self, buffer, offset, &length,
                                           error)) {
    return nullptr;
  }
  if (!read_align(buffer, offset, 8, error)) {
    return nullptr;
  }
  if (!check_size(buffer, *offset, sizeof(double) * length, error)) {
    return nullptr;
  }
  FlValue* value = fl_value_new_float_list(
      reinterpret_cast<const double*>(get_data(buffer, offset)), length);
  *offset += sizeof(double) * length;
  return value;
}

References check_size(), error, fl_standard_message_codec_read_size(), fl_value_new_float_list(), get_data(), length, read_align(), self, and value.

Referenced by fl_standard_message_codec_read_value_of_type().

◆ read_float64_value()

static FlValue * read_float64_value	(	GBytes *	buffer,
		size_t *	offset,
		GError **	error
	)

static

Definition at line 189 of file fl_standard_message_codec.cc.

                                                   {
  if (!read_align(buffer, offset, 8, error)) {
    return nullptr;
  }
  if (!check_size(buffer, *offset, sizeof(double), error)) {
    return nullptr;
  }
 
  FlValue* value = fl_value_new_float(
      reinterpret_cast<const double*>(get_data(buffer, offset))[0]);
  *offset += sizeof(double);
  return value;
}

References check_size(), error, fl_value_new_float(), get_data(), read_align(), and value.

Referenced by fl_standard_message_codec_read_value_of_type().

◆ read_int32_list_value()

static FlValue * read_int32_list_value	(	FlStandardMessageCodec *	self,
		GBytes *	buffer,
		size_t *	offset,
		GError **	error
	)

static

Definition at line 249 of file fl_standard_message_codec.cc.

                                                      {
  uint32_t length;
  if (!fl_standard_message_codec_read_size(self, buffer, offset, &length,
                                           error)) {
    return nullptr;
  }
  if (!read_align(buffer, offset, 4, error)) {
    return nullptr;
  }
  if (!check_size(buffer, *offset, sizeof(int32_t) * length, error)) {
    return nullptr;
  }
  FlValue* value = fl_value_new_int32_list(
      reinterpret_cast<const int32_t*>(get_data(buffer, offset)), length);
  *offset += sizeof(int32_t) * length;
  return value;
}

References check_size(), error, fl_standard_message_codec_read_size(), fl_value_new_int32_list(), get_data(), length, read_align(), self, and value.

Referenced by fl_standard_message_codec_read_value_of_type().

◆ read_int32_value()

static FlValue * read_int32_value	(	GBytes *	buffer,
		size_t *	offset,
		GError **	error
	)

static

Definition at line 157 of file fl_standard_message_codec.cc.

                                                 {
  if (!check_size(buffer, *offset, sizeof(int32_t), error)) {
    return nullptr;
  }
 
  FlValue* value = fl_value_new_int(
      reinterpret_cast<const int32_t*>(get_data(buffer, offset))[0]);
  *offset += sizeof(int32_t);
  return value;
}

References check_size(), error, fl_value_new_int(), get_data(), and value.

Referenced by fl_standard_message_codec_read_value_of_type().

◆ read_int64_list_value()

static FlValue * read_int64_list_value	(	FlStandardMessageCodec *	self,
		GBytes *	buffer,
		size_t *	offset,
		GError **	error
	)

static

Definition at line 273 of file fl_standard_message_codec.cc.

                                                      {
  uint32_t length;
  if (!fl_standard_message_codec_read_size(self, buffer, offset, &length,
                                           error)) {
    return nullptr;
  }
  if (!read_align(buffer, offset, 8, error)) {
    return nullptr;
  }
  if (!check_size(buffer, *offset, sizeof(int64_t) * length, error)) {
    return nullptr;
  }
  FlValue* value = fl_value_new_int64_list(
      reinterpret_cast<const int64_t*>(get_data(buffer, offset)), length);
  *offset += sizeof(int64_t) * length;
  return value;
}

References check_size(), error, fl_standard_message_codec_read_size(), fl_value_new_int64_list(), get_data(), length, read_align(), self, and value.

Referenced by fl_standard_message_codec_read_value_of_type().

◆ read_int64_value()

static FlValue * read_int64_value	(	GBytes *	buffer,
		size_t *	offset,
		GError **	error
	)

static

Definition at line 173 of file fl_standard_message_codec.cc.

                                                 {
  if (!check_size(buffer, *offset, sizeof(int64_t), error)) {
    return nullptr;
  }
 
  FlValue* value = fl_value_new_int(
      reinterpret_cast<const int64_t*>(get_data(buffer, offset))[0]);
  *offset += sizeof(int64_t);
  return value;
}

References check_size(), error, fl_value_new_int(), get_data(), and value.

Referenced by fl_standard_message_codec_read_value_of_type().

◆ read_list_value()

static FlValue * read_list_value	(	FlStandardMessageCodec *	self,
		GBytes *	buffer,
		size_t *	offset,
		GError **	error
	)

static

Definition at line 345 of file fl_standard_message_codec.cc.

                                                {
  uint32_t length;
  if (!fl_standard_message_codec_read_size(self, buffer, offset, &length,
                                           error)) {
    return nullptr;
  }
 
  g_autoptr(FlValue) list = fl_value_new_list();
  for (size_t i = 0; i < length; i++) {
    g_autoptr(FlValue) child =
        fl_standard_message_codec_read_value(self, buffer, offset, error);
    if (child == nullptr) {
      return nullptr;
    }
    fl_value_append(list, child);
  }
 
  return fl_value_ref(list);
}

References error, fl_standard_message_codec_read_size(), fl_standard_message_codec_read_value(), fl_value_append(), fl_value_new_list(), fl_value_ref(), g_autoptr(), i, length, and self.

Referenced by fl_standard_message_codec_read_value_of_type().

◆ read_map_value()

static FlValue * read_map_value	(	FlStandardMessageCodec *	self,
		GBytes *	buffer,
		size_t *	offset,
		GError **	error
	)

static

Definition at line 371 of file fl_standard_message_codec.cc.

                                               {
  uint32_t length;
  if (!fl_standard_message_codec_read_size(self, buffer, offset, &length,
                                           error)) {
    return nullptr;
  }
 
  g_autoptr(FlValue) map = fl_value_new_map();
  for (size_t i = 0; i < length; i++) {
    g_autoptr(FlValue) key =
        fl_standard_message_codec_read_value(self, buffer, offset, error);
    if (key == nullptr) {
      return nullptr;
    }
    g_autoptr(FlValue) value =
        fl_standard_message_codec_read_value(self, buffer, offset, error);
    if (value == nullptr) {
      return nullptr;
    }
    fl_value_set(map, key, value);
  }
 
  return fl_value_ref(map);
}

References error, fl_standard_message_codec_read_size(), fl_standard_message_codec_read_value(), fl_value_new_map(), fl_value_ref(), fl_value_set(), g_autoptr(), i, key, length, self, and value.

Referenced by fl_standard_message_codec_read_value_of_type().

◆ read_string_value()

static FlValue * read_string_value	(	FlStandardMessageCodec *	self,
		GBytes *	buffer,
		size_t *	offset,
		GError **	error
	)

static

Definition at line 208 of file fl_standard_message_codec.cc.

                                                  {
  uint32_t length;
  if (!fl_standard_message_codec_read_size(self, buffer, offset, &length,
                                           error)) {
    return nullptr;
  }
  if (!check_size(buffer, *offset, length, error)) {
    return nullptr;
  }
  FlValue* value = fl_value_new_string_sized(
      reinterpret_cast<const gchar*>(get_data(buffer, offset)), length);
  *offset += length;
  return value;
}

References check_size(), error, fl_standard_message_codec_read_size(), fl_value_new_string_sized(), get_data(), length, self, and value.

Referenced by fl_standard_message_codec_read_value_of_type().

◆ read_uint16()

static gboolean read_uint16	(	GBytes *	buffer,
		size_t *	offset,
		uint16_t *	value,
		GError **	error
	)

static

Definition at line 126 of file fl_standard_message_codec.cc.

                                            {
  if (!check_size(buffer, *offset, sizeof(uint16_t), error)) {
    return FALSE;
  }
 
  *value = reinterpret_cast<const uint16_t*>(get_data(buffer, offset))[0];
  *offset += sizeof(uint16_t);
  return TRUE;
}

References check_size(), error, get_data(), TRUE, and value.

Referenced by fl_standard_message_codec_read_size().

◆ read_uint32()

static gboolean read_uint32	(	GBytes *	buffer,
		size_t *	offset,
		uint32_t *	value,
		GError **	error
	)

static

Definition at line 141 of file fl_standard_message_codec.cc.

                                            {
  if (!check_size(buffer, *offset, sizeof(uint32_t), error)) {
    return FALSE;
  }
 
  *value = reinterpret_cast<const uint32_t*>(get_data(buffer, offset))[0];
  *offset += sizeof(uint32_t);
  return TRUE;
}

References check_size(), error, get_data(), TRUE, and value.

Referenced by fl_standard_message_codec_read_size().

◆ read_uint8()

static gboolean read_uint8	(	GBytes *	buffer,
		size_t *	offset,
		uint8_t *	value,
		GError **	error
	)

static

Definition at line 111 of file fl_standard_message_codec.cc.

                                           {
  if (!check_size(buffer, *offset, sizeof(uint8_t), error)) {
    return FALSE;
  }
 
  *value = get_data(buffer, offset)[0];
  (*offset)++;
  return TRUE;
}

References check_size(), error, get_data(), TRUE, and value.

Referenced by fl_standard_message_codec_read_size(), and fl_standard_message_codec_read_value().

◆ read_uint8_list_value()

static FlValue * read_uint8_list_value	(	FlStandardMessageCodec *	self,
		GBytes *	buffer,
		size_t *	offset,
		GError **	error
	)

static

Definition at line 229 of file fl_standard_message_codec.cc.

                                                      {
  uint32_t length;
  if (!fl_standard_message_codec_read_size(self, buffer, offset, &length,
                                           error)) {
    return nullptr;
  }
  if (!check_size(buffer, *offset, sizeof(uint8_t) * length, error)) {
    return nullptr;
  }
  FlValue* value = fl_value_new_uint8_list(get_data(buffer, offset), length);
  *offset += length;
  return value;
}

References check_size(), error, fl_standard_message_codec_read_size(), fl_value_new_uint8_list(), get_data(), length, self, and value.

Referenced by fl_standard_message_codec_read_value_of_type().

◆ write_align()

static void write_align	(	GByteArray *	buffer,
		guint	align
	)

static

Definition at line 66 of file fl_standard_message_codec.cc.

                                                         {
  while (buffer->len % align != 0) {
    write_uint8(buffer, 0);
  }
}

Referenced by fl_standard_message_codec_real_write_value().

◆ write_float64()

static void write_float64	(	GByteArray *	buffer,
		double	value
	)

static

Definition at line 60 of file fl_standard_message_codec.cc.

                                                            {
  g_byte_array_append(buffer, reinterpret_cast<uint8_t*>(&value),
                      sizeof(double));
}

References g_byte_array_append(), and value.

Referenced by fl_standard_message_codec_real_write_value().

◆ write_int32()

static void write_int32	(	GByteArray *	buffer,
		int32_t	value
	)

static

Definition at line 50 of file fl_standard_message_codec.cc.

                                                           {
  g_byte_array_append(buffer, reinterpret_cast<uint8_t*>(&value),
                      sizeof(int32_t));
}

References g_byte_array_append(), and value.

Referenced by fl_standard_message_codec_real_write_value().

◆ write_int64()

static void write_int64	(	GByteArray *	buffer,
		int64_t	value
	)

static

Definition at line 55 of file fl_standard_message_codec.cc.

                                                           {
  g_byte_array_append(buffer, reinterpret_cast<uint8_t*>(&value),
                      sizeof(int64_t));
}

References g_byte_array_append(), and value.

Referenced by fl_standard_message_codec_real_write_value().

◆ write_uint16()

static void write_uint16	(	GByteArray *	buffer,
		uint16_t	value
	)

static

Definition at line 40 of file fl_standard_message_codec.cc.

                                                             {
  g_byte_array_append(buffer, reinterpret_cast<uint8_t*>(&value),
                      sizeof(uint16_t));
}

References g_byte_array_append(), and value.

Referenced by fl_standard_message_codec_write_size().

◆ write_uint32()

static void write_uint32	(	GByteArray *	buffer,
		uint32_t	value
	)

static

Definition at line 45 of file fl_standard_message_codec.cc.

                                                             {
  g_byte_array_append(buffer, reinterpret_cast<uint8_t*>(&value),
                      sizeof(uint32_t));
}