fl_standard_message_codec.cc File Reference

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

Go to the source code of this file.

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;
}

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;
}

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);
}

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)));
}

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.

{}

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));
}

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 657 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;
}

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);
}

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);
}

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;
}

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);
  }
}

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 685 of file fl_standard_message_codec.cc.

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

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;
}

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;
}

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;
}

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;
}

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;
}

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;
}

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;
}

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;
}

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;
}

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);
}

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);
}

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;
}

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;
}

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;
}

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;
}

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;
}

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);
  }
}

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));
}

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));
}

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));
}

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));
}

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));
}

Variable Documentation

kValueFalse

constexpr int kValueFalse = 2

staticconstexpr

Definition at line 17 of file fl_standard_message_codec.cc.

kValueFloat32List

constexpr int kValueFloat32List = 14

staticconstexpr

Definition at line 28 of file fl_standard_message_codec.cc.

kValueFloat64

constexpr int kValueFloat64 = 6

staticconstexpr

Definition at line 20 of file fl_standard_message_codec.cc.

kValueFloat64List

constexpr int kValueFloat64List = 11

staticconstexpr

Definition at line 25 of file fl_standard_message_codec.cc.

kValueInt32

constexpr int kValueInt32 = 3

staticconstexpr

Definition at line 18 of file fl_standard_message_codec.cc.

kValueInt32List

constexpr int kValueInt32List = 9

staticconstexpr

Definition at line 23 of file fl_standard_message_codec.cc.

kValueInt64

constexpr int kValueInt64 = 4

staticconstexpr

Definition at line 19 of file fl_standard_message_codec.cc.

kValueInt64List

constexpr int kValueInt64List = 10

staticconstexpr

Definition at line 24 of file fl_standard_message_codec.cc.

kValueList

constexpr int kValueList = 12

staticconstexpr

Definition at line 26 of file fl_standard_message_codec.cc.

kValueMap

constexpr int kValueMap = 13

staticconstexpr

Definition at line 27 of file fl_standard_message_codec.cc.

kValueNull

constexpr int kValueNull = 0

staticconstexpr

Definition at line 15 of file fl_standard_message_codec.cc.

kValueString

constexpr int kValueString = 7

staticconstexpr

Definition at line 21 of file fl_standard_message_codec.cc.

kValueTrue

constexpr int kValueTrue = 1

staticconstexpr

Definition at line 16 of file fl_standard_message_codec.cc.

kValueUint8List

constexpr int kValueUint8List = 8

staticconstexpr

Definition at line 22 of file fl_standard_message_codec.cc.

value

uint8_t value

Initial value:

{
  g_byte_array_append(buffer, &value, sizeof(uint8_t))

Definition at line 36 of file fl_standard_message_codec.cc.