fl_value.cc File Reference

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

Go to the source code of this file.

Classes
struct	_FlValue
struct	FlValueBool
struct	FlValueInt
struct	FlValueDouble
struct	FlValueString
struct	FlValueUint8List
struct	FlValueInt32List
struct	FlValueInt64List
struct	FlValueFloat32List
struct	FlValueFloatList
struct	FlValueList
struct	FlValueMap
struct	FlValueCustom

Functions
static FlValue *	fl_value_new (FlValueType type, size_t size)
static void	fl_value_destroy (gpointer value)
static ssize_t	fl_value_lookup_index (FlValue *self, FlValue *key)
static void	int_to_string (int64_t value, GString *buffer)
static void	float_to_string (double value, GString *buffer)
static void	value_to_string (FlValue *value, GString *buffer)
G_MODULE_EXPORT FlValue *	fl_value_new_null ()
G_MODULE_EXPORT FlValue *	fl_value_new_bool (bool value)
G_MODULE_EXPORT FlValue *	fl_value_new_int (int64_t value)
G_MODULE_EXPORT FlValue *	fl_value_new_float (double value)
G_MODULE_EXPORT FlValue *	fl_value_new_string (const gchar *value)
G_MODULE_EXPORT FlValue *	fl_value_new_string_sized (const gchar *value, size_t value_length)
G_MODULE_EXPORT FlValue *	fl_value_new_uint8_list (const uint8_t *data, size_t data_length)
G_MODULE_EXPORT FlValue *	fl_value_new_uint8_list_from_bytes (GBytes *data)
G_MODULE_EXPORT FlValue *	fl_value_new_int32_list (const int32_t *data, size_t data_length)
G_MODULE_EXPORT FlValue *	fl_value_new_int64_list (const int64_t *data, size_t data_length)
G_MODULE_EXPORT FlValue *	fl_value_new_float32_list (const float *data, size_t data_length)
G_MODULE_EXPORT FlValue *	fl_value_new_float_list (const double *data, size_t data_length)
G_MODULE_EXPORT FlValue *	fl_value_new_list ()
G_MODULE_EXPORT FlValue *	fl_value_new_list_from_strv (const gchar *const *str_array)
G_MODULE_EXPORT FlValue *	fl_value_new_map ()
G_MODULE_EXPORT FlValue *	fl_value_new_custom (int type, gconstpointer value, GDestroyNotify destroy_notify)
G_MODULE_EXPORT FlValue *	fl_value_new_custom_object (int type, GObject *object)
G_MODULE_EXPORT FlValue *	fl_value_new_custom_object_take (int type, GObject *object)
G_MODULE_EXPORT FlValue *	fl_value_ref (FlValue *self)
G_MODULE_EXPORT void	fl_value_unref (FlValue *self)
G_MODULE_EXPORT FlValueType	fl_value_get_type (FlValue *self)
G_MODULE_EXPORT bool	fl_value_equal (FlValue *a, FlValue *b)
G_MODULE_EXPORT void	fl_value_append (FlValue *self, FlValue *value)
G_MODULE_EXPORT void	fl_value_append_take (FlValue *self, FlValue *value)
G_MODULE_EXPORT void	fl_value_set (FlValue *self, FlValue *key, FlValue *value)
G_MODULE_EXPORT void	fl_value_set_take (FlValue *self, FlValue *key, FlValue *value)
G_MODULE_EXPORT void	fl_value_set_string (FlValue *self, const gchar *key, FlValue *value)
G_MODULE_EXPORT void	fl_value_set_string_take (FlValue *self, const gchar *key, FlValue *value)
G_MODULE_EXPORT bool	fl_value_get_bool (FlValue *self)
G_MODULE_EXPORT int64_t	fl_value_get_int (FlValue *self)
G_MODULE_EXPORT double	fl_value_get_float (FlValue *self)
G_MODULE_EXPORT const gchar *	fl_value_get_string (FlValue *self)
G_MODULE_EXPORT const uint8_t *	fl_value_get_uint8_list (FlValue *self)
G_MODULE_EXPORT const int32_t *	fl_value_get_int32_list (FlValue *self)
G_MODULE_EXPORT const int64_t *	fl_value_get_int64_list (FlValue *self)
G_MODULE_EXPORT const float *	fl_value_get_float32_list (FlValue *self)
G_MODULE_EXPORT const double *	fl_value_get_float_list (FlValue *self)
G_MODULE_EXPORT size_t	fl_value_get_length (FlValue *self)
G_MODULE_EXPORT FlValue *	fl_value_get_list_value (FlValue *self, size_t index)
G_MODULE_EXPORT FlValue *	fl_value_get_map_key (FlValue *self, size_t index)
G_MODULE_EXPORT FlValue *	fl_value_get_map_value (FlValue *self, size_t index)
G_MODULE_EXPORT FlValue *	fl_value_lookup (FlValue *self, FlValue *key)
G_MODULE_EXPORT FlValue *	fl_value_lookup_string (FlValue *self, const gchar *key)
G_MODULE_EXPORT int	fl_value_get_custom_type (FlValue *self)
G_MODULE_EXPORT gconstpointer	fl_value_get_custom_value (FlValue *self)
G_MODULE_EXPORT GObject *	fl_value_get_custom_value_object (FlValue *self)
G_MODULE_EXPORT gchar *	fl_value_to_string (FlValue *value)

Function Documentation

fl_value_append()

G_MODULE_EXPORT void fl_value_append	(	FlValue *	value,
		FlValue *	child
	)

fl_value_append: @value: an FlValue of type FL_VALUE_TYPE_LIST. @child: an FlValue.

Adds @child to the end of @value. Calling this with an FlValue that is not of type FL_VALUE_TYPE_LIST is a programming error.

Definition at line 592 of file fl_value.cc.

                                                                    {
  g_return_if_fail(self != nullptr);
  g_return_if_fail(self->type == FL_VALUE_TYPE_LIST);
  g_return_if_fail(value != nullptr);
 
  fl_value_append_take(self, fl_value_ref(value));
}

fl_value_append_take()

G_MODULE_EXPORT void fl_value_append_take	(	FlValue *	value,
		FlValue *	child
	)

fl_value_append_take: @value: an FlValue of type FL_VALUE_TYPE_LIST. @child: (transfer full): an FlValue.

Adds @child to the end of @value. Ownership of @child is taken by @value. Calling this with an FlValue that is not of type FL_VALUE_TYPE_LIST is a programming error.

Definition at line 600 of file fl_value.cc.

                                                                         {
  g_return_if_fail(self != nullptr);
  g_return_if_fail(self->type == FL_VALUE_TYPE_LIST);
  g_return_if_fail(value != nullptr);
 
  FlValueList* v = reinterpret_cast<FlValueList*>(self);
  g_ptr_array_add(v->values, value);
}

fl_value_destroy()

static void fl_value_destroy ( gpointer  value )

static

Definition at line 92 of file fl_value.cc.

                                             {
  fl_value_unref(static_cast<FlValue*>(value));
}

fl_value_equal()

G_MODULE_EXPORT bool fl_value_equal	(	FlValue *	a,
		FlValue *	b
	)

fl_value_equal: : an FlValue. : an FlValue.

Compares two FlValue to see if they are equivalent. Two values are considered equivalent if they are of the same type and their data is the same including any child values. For values of type FL_VALUE_TYPE_MAP the order of the values does not matter.

Returns: TRUE if both values are equivalent.

Definition at line 471 of file fl_value.cc.

                                                            {
  g_return_val_if_fail(a != nullptr, false);
  g_return_val_if_fail(b != nullptr, false);
 
  if (a->type != b->type) {
    return false;
  }
 
  switch (a->type) {
    case FL_VALUE_TYPE_NULL:
      return true;
    case FL_VALUE_TYPE_BOOL:
      return fl_value_get_bool(a) == fl_value_get_bool(b);
    case FL_VALUE_TYPE_INT:
      return fl_value_get_int(a) == fl_value_get_int(b);
    case FL_VALUE_TYPE_FLOAT:
      return fl_value_get_float(a) == fl_value_get_float(b);
    case FL_VALUE_TYPE_STRING: {
      FlValueString* a_ = reinterpret_cast<FlValueString*>(a);
      FlValueString* b_ = reinterpret_cast<FlValueString*>(b);
      return g_strcmp0(a_->value, b_->value) == 0;
    }
    case FL_VALUE_TYPE_UINT8_LIST: {
      if (fl_value_get_length(a) != fl_value_get_length(b)) {
        return false;
      }
      const uint8_t* values_a = fl_value_get_uint8_list(a);
      const uint8_t* values_b = fl_value_get_uint8_list(b);
      for (size_t i = 0; i < fl_value_get_length(a); i++) {
        if (values_a[i] != values_b[i]) {
          return false;
        }
      }
      return true;
    }
    case FL_VALUE_TYPE_INT32_LIST: {
      if (fl_value_get_length(a) != fl_value_get_length(b)) {
        return false;
      }
      const int32_t* values_a = fl_value_get_int32_list(a);
      const int32_t* values_b = fl_value_get_int32_list(b);
      for (size_t i = 0; i < fl_value_get_length(a); i++) {
        if (values_a[i] != values_b[i]) {
          return false;
        }
      }
      return true;
    }
    case FL_VALUE_TYPE_INT64_LIST: {
      if (fl_value_get_length(a) != fl_value_get_length(b)) {
        return false;
      }
      const int64_t* values_a = fl_value_get_int64_list(a);
      const int64_t* values_b = fl_value_get_int64_list(b);
      for (size_t i = 0; i < fl_value_get_length(a); i++) {
        if (values_a[i] != values_b[i]) {
          return false;
        }
      }
      return true;
    }
    case FL_VALUE_TYPE_FLOAT32_LIST: {
      if (fl_value_get_length(a) != fl_value_get_length(b)) {
        return false;
      }
      const float* values_a = fl_value_get_float32_list(a);
      const float* values_b = fl_value_get_float32_list(b);
      for (size_t i = 0; i < fl_value_get_length(a); i++) {
        if (values_a[i] != values_b[i]) {
          return false;
        }
      }
      return true;
    }
    case FL_VALUE_TYPE_FLOAT_LIST: {
      if (fl_value_get_length(a) != fl_value_get_length(b)) {
        return false;
      }
      const double* values_a = fl_value_get_float_list(a);
      const double* values_b = fl_value_get_float_list(b);
      for (size_t i = 0; i < fl_value_get_length(a); i++) {
        if (values_a[i] != values_b[i]) {
          return false;
        }
      }
      return true;
    }
    case FL_VALUE_TYPE_LIST: {
      if (fl_value_get_length(a) != fl_value_get_length(b)) {
        return false;
      }
      for (size_t i = 0; i < fl_value_get_length(a); i++) {
        if (!fl_value_equal(fl_value_get_list_value(a, i),
                            fl_value_get_list_value(b, i))) {
          return false;
        }
      }
      return true;
    }
    case FL_VALUE_TYPE_MAP: {
      if (fl_value_get_length(a) != fl_value_get_length(b)) {
        return false;
      }
      for (size_t i = 0; i < fl_value_get_length(a); i++) {
        FlValue* key = fl_value_get_map_key(a, i);
        FlValue* value_b = fl_value_lookup(b, key);
        if (value_b == nullptr) {
          return false;
        }
        FlValue* value_a = fl_value_get_map_value(a, i);
        if (!fl_value_equal(value_a, value_b)) {
          return false;
        }
      }
      return true;
    }
    case FL_VALUE_TYPE_CUSTOM:
      return false;
  }
}

fl_value_get_bool()

G_MODULE_EXPORT bool fl_value_get_bool

(

FlValue *

value

)

fl_value_get_bool: @value: an FlValue of type FL_VALUE_TYPE_BOOL.

Gets the boolean value of @value. Calling this with an FlValue that is not of type FL_VALUE_TYPE_BOOL is a programming error.

Returns: a boolean value.

Definition at line 661 of file fl_value.cc.

                                                      {
  g_return_val_if_fail(self != nullptr, FALSE);
  g_return_val_if_fail(self->type == FL_VALUE_TYPE_BOOL, FALSE);
  FlValueBool* v = reinterpret_cast<FlValueBool*>(self);
  return v->value;
}

fl_value_get_custom_type()

G_MODULE_EXPORT int fl_value_get_custom_type

(

FlValue *

value

)

fl_value_get_custom_type: @value: an FlValue of type FL_VALUE_TYPE_CUSTOM.

Gets the type ID for this custom type.

Returns: a type ID.

Definition at line 822 of file fl_value.cc.

                                                            {
  g_return_val_if_fail(self != nullptr, -1);
  g_return_val_if_fail(self->type == FL_VALUE_TYPE_CUSTOM, -1);
 
  FlValueCustom* v = reinterpret_cast<FlValueCustom*>(self);
  return v->type;
}

fl_value_get_custom_value()

G_MODULE_EXPORT gconstpointer fl_value_get_custom_value

(

FlValue *

value

)

fl_value_get_custom_value: @value: an FlValue of type FL_VALUE_TYPE_CUSTOM.

Gets the address of the custom value.

Returns: a pointer to the custom value.

Definition at line 830 of file fl_value.cc.

                                                                       {
  g_return_val_if_fail(self != nullptr, nullptr);
  g_return_val_if_fail(self->type == FL_VALUE_TYPE_CUSTOM, nullptr);
 
  FlValueCustom* v = reinterpret_cast<FlValueCustom*>(self);
  return v->value;
}

fl_value_get_custom_value_object()

G_MODULE_EXPORT GObject * fl_value_get_custom_value_object

(

FlValue *

value

)

fl_value_get_custom_value_object: @value: an FlValue of type FL_VALUE_TYPE_CUSTOM.

Gets the custom value as an object.

Returns: an object.

Definition at line 838 of file fl_value.cc.

                                                                         {
  g_return_val_if_fail(self != nullptr, nullptr);
  g_return_val_if_fail(self->type == FL_VALUE_TYPE_CUSTOM, nullptr);
 
  FlValueCustom* v = reinterpret_cast<FlValueCustom*>(self);
  return G_OBJECT(v->value);
}

fl_value_get_float()

G_MODULE_EXPORT double fl_value_get_float

(

FlValue *

value

)

fl_value_get_float: @value: an FlValue of type FL_VALUE_TYPE_FLOAT.

Gets the floating point number of @value. Calling this with an FlValue that is not of type FL_VALUE_TYPE_FLOAT is a programming error.

Returns: a floating point number.

Definition at line 675 of file fl_value.cc.

                                                         {
  g_return_val_if_fail(self != nullptr, 0.0);
  g_return_val_if_fail(self->type == FL_VALUE_TYPE_FLOAT, 0.0);
  FlValueDouble* v = reinterpret_cast<FlValueDouble*>(self);
  return v->value;
}

fl_value_get_float32_list()

G_MODULE_EXPORT const float * fl_value_get_float32_list

(

FlValue *

value

)

fl_value_get_float32_list: @value: an FlValue of type FL_VALUE_TYPE_FLOAT32_LIST.

Gets the array of floating point numbers @value contains. The data contains fl_value_get_length() elements. Calling this with an FlValue that is not of type FL_VALUE_TYPE_FLOAT32_LIST is a programming error.

Returns: an array of floating point numbers.

Definition at line 710 of file fl_value.cc.

                                                                      {
  g_return_val_if_fail(self != nullptr, nullptr);
  g_return_val_if_fail(self->type == FL_VALUE_TYPE_FLOAT32_LIST, nullptr);
  FlValueFloat32List* v = reinterpret_cast<FlValueFloat32List*>(self);
  return v->values;
}

fl_value_get_float_list()

G_MODULE_EXPORT const double * fl_value_get_float_list

(

FlValue *

value

)

fl_value_get_float_list: @value: an FlValue of type FL_VALUE_TYPE_FLOAT_LIST.

Gets the array of floating point numbers @value contains. The data contains fl_value_get_length() elements. Calling this with an FlValue that is not of type FL_VALUE_TYPE_FLOAT_LIST is a programming error.

Returns: an array of floating point numbers.

Definition at line 717 of file fl_value.cc.

                                                                     {
  g_return_val_if_fail(self != nullptr, nullptr);
  g_return_val_if_fail(self->type == FL_VALUE_TYPE_FLOAT_LIST, nullptr);
  FlValueFloatList* v = reinterpret_cast<FlValueFloatList*>(self);
  return v->values;
}

fl_value_get_int()

G_MODULE_EXPORT int64_t fl_value_get_int

(

FlValue *

value

)

fl_value_get_int: @value: an FlValue of type FL_VALUE_TYPE_INT.

Gets the integer number of @value. Calling this with an FlValue that is not of type FL_VALUE_TYPE_INT is a programming error.

Returns: an integer number.

Definition at line 668 of file fl_value.cc.

                                                        {
  g_return_val_if_fail(self != nullptr, 0);
  g_return_val_if_fail(self->type == FL_VALUE_TYPE_INT, 0);
  FlValueInt* v = reinterpret_cast<FlValueInt*>(self);
  return v->value;
}

fl_value_get_int32_list()

G_MODULE_EXPORT const int32_t * fl_value_get_int32_list

(

FlValue *

value

)

fl_value_get_int32_list: @value: an FlValue of type FL_VALUE_TYPE_INT32_LIST.

Gets the array of 32 bit integers @value contains. The data contains fl_value_get_length() elements. Calling this with an FlValue that is not of type FL_VALUE_TYPE_INT32_LIST is a programming error.

Returns: an array of 32 bit integers.

Definition at line 696 of file fl_value.cc.

                                                                      {
  g_return_val_if_fail(self != nullptr, nullptr);
  g_return_val_if_fail(self->type == FL_VALUE_TYPE_INT32_LIST, nullptr);
  FlValueInt32List* v = reinterpret_cast<FlValueInt32List*>(self);
  return v->values;
}

fl_value_get_int64_list()

G_MODULE_EXPORT const int64_t * fl_value_get_int64_list

(

FlValue *

value

)

fl_value_get_int64_list: @value: an FlValue of type FL_VALUE_TYPE_INT64_LIST.

Gets the array of 64 bit integers @value contains. The data contains fl_value_get_length() elements. Calling this with an FlValue that is not of type FL_VALUE_TYPE_INT64_LIST is a programming error.

Returns: an array of 64 bit integers.

Definition at line 703 of file fl_value.cc.

                                                                      {
  g_return_val_if_fail(self != nullptr, nullptr);
  g_return_val_if_fail(self->type == FL_VALUE_TYPE_INT64_LIST, nullptr);
  FlValueInt64List* v = reinterpret_cast<FlValueInt64List*>(self);
  return v->values;
}

fl_value_get_length()

G_MODULE_EXPORT size_t fl_value_get_length

(

FlValue *

value

)

fl_value_get_length: @value: an FlValue of type FL_VALUE_TYPE_UINT8_LIST, FL_VALUE_TYPE_INT32_LIST, FL_VALUE_TYPE_INT64_LIST, FL_VALUE_TYPE_FLOAT32_LIST, FL_VALUE_TYPE_FLOAT_LIST, FL_VALUE_TYPE_LIST or FL_VALUE_TYPE_MAP.

Gets the number of elements @value contains. This is only valid for list and map types. Calling this with other types is a programming error.

Returns: the number of elements inside @value.

Definition at line 724 of file fl_value.cc.

                                                          {
  g_return_val_if_fail(self != nullptr, 0);
  g_return_val_if_fail(self->type == FL_VALUE_TYPE_UINT8_LIST ||
                           self->type == FL_VALUE_TYPE_INT32_LIST ||
                           self->type == FL_VALUE_TYPE_INT64_LIST ||
                           self->type == FL_VALUE_TYPE_FLOAT32_LIST ||
                           self->type == FL_VALUE_TYPE_FLOAT_LIST ||
                           self->type == FL_VALUE_TYPE_LIST ||
                           self->type == FL_VALUE_TYPE_MAP,
                       0);
 
  switch (self->type) {
    case FL_VALUE_TYPE_UINT8_LIST: {
      FlValueUint8List* v = reinterpret_cast<FlValueUint8List*>(self);
      return v->values_length;
    }
    case FL_VALUE_TYPE_INT32_LIST: {
      FlValueInt32List* v = reinterpret_cast<FlValueInt32List*>(self);
      return v->values_length;
    }
    case FL_VALUE_TYPE_INT64_LIST: {
      FlValueInt64List* v = reinterpret_cast<FlValueInt64List*>(self);
      return v->values_length;
    }
    case FL_VALUE_TYPE_FLOAT32_LIST: {
      FlValueFloat32List* v = reinterpret_cast<FlValueFloat32List*>(self);
      return v->values_length;
    }
    case FL_VALUE_TYPE_FLOAT_LIST: {
      FlValueFloatList* v = reinterpret_cast<FlValueFloatList*>(self);
      return v->values_length;
    }
    case FL_VALUE_TYPE_LIST: {
      FlValueList* v = reinterpret_cast<FlValueList*>(self);
      return v->values->len;
    }
    case FL_VALUE_TYPE_MAP: {
      FlValueMap* v = reinterpret_cast<FlValueMap*>(self);
      return v->keys->len;
    }
    case FL_VALUE_TYPE_NULL:
    case FL_VALUE_TYPE_BOOL:
    case FL_VALUE_TYPE_INT:
    case FL_VALUE_TYPE_FLOAT:
    case FL_VALUE_TYPE_STRING:
    case FL_VALUE_TYPE_CUSTOM:
      return 0;
  }
 
  return 0;
}

fl_value_get_list_value()

G_MODULE_EXPORT FlValue * fl_value_get_list_value	(	FlValue *	value,
		size_t	index
	)

fl_value_get_list_value: @value: an FlValue of type FL_VALUE_TYPE_LIST. @index: an index in the list.

Gets a child element of the list. It is a programming error to request an index that is outside the size of the list as returned from fl_value_get_length(). Calling this with an FlValue that is not of type FL_VALUE_TYPE_LIST is a programming error.

Returns: an FlValue.

Definition at line 776 of file fl_value.cc.

                                                                              {
  g_return_val_if_fail(self != nullptr, nullptr);
  g_return_val_if_fail(self->type == FL_VALUE_TYPE_LIST, nullptr);
 
  FlValueList* v = reinterpret_cast<FlValueList*>(self);
  return static_cast<FlValue*>(g_ptr_array_index(v->values, index));
}

fl_value_get_map_key()

G_MODULE_EXPORT FlValue * fl_value_get_map_key	(	FlValue *	value,
		size_t	index
	)

fl_value_get_map_key: @value: an FlValue of type FL_VALUE_TYPE_MAP. @index: an index in the map.

Gets a key from the map. It is a programming error to request an index that is outside the size of the list as returned from fl_value_get_length(). Calling this with an FlValue that is not of type FL_VALUE_TYPE_MAP is a programming error.

Returns: an FlValue.

Definition at line 784 of file fl_value.cc.

                                                                           {
  g_return_val_if_fail(self != nullptr, nullptr);
  g_return_val_if_fail(self->type == FL_VALUE_TYPE_MAP, nullptr);
 
  FlValueMap* v = reinterpret_cast<FlValueMap*>(self);
  return static_cast<FlValue*>(g_ptr_array_index(v->keys, index));
}

fl_value_get_map_value()

G_MODULE_EXPORT FlValue * fl_value_get_map_value	(	FlValue *	value,
		size_t	index
	)

fl_value_get_map_value: @value: an FlValue of type FL_VALUE_TYPE_MAP. @index: an index in the map.

Gets a value from the map. It is a programming error to request an index that is outside the size of the list as returned from fl_value_get_length(). Calling this with an FlValue that is not of type FL_VALUE_TYPE_MAP is a programming error.

Returns: an FlValue.

Definition at line 792 of file fl_value.cc.

                                                                             {
  g_return_val_if_fail(self != nullptr, nullptr);
  g_return_val_if_fail(self->type == FL_VALUE_TYPE_MAP, nullptr);
 
  FlValueMap* v = reinterpret_cast<FlValueMap*>(self);
  return static_cast<FlValue*>(g_ptr_array_index(v->values, index));
}

fl_value_get_string()

G_MODULE_EXPORT const gchar * fl_value_get_string

(

FlValue *

value

)

fl_value_get_string: @value: an FlValue of type FL_VALUE_TYPE_STRING.

Gets the UTF-8 text contained in @value. Calling this with an FlValue that is not of type FL_VALUE_TYPE_STRING is a programming error.

Returns: a UTF-8 encoded string.

Definition at line 682 of file fl_value.cc.

                                                                {
  g_return_val_if_fail(self != nullptr, nullptr);
  g_return_val_if_fail(self->type == FL_VALUE_TYPE_STRING, nullptr);
  FlValueString* v = reinterpret_cast<FlValueString*>(self);
  return v->value;
}

fl_value_get_type()

G_MODULE_EXPORT FlValueType fl_value_get_type

(

FlValue *

value

)

fl_value_get_type: @value: an FlValue.

Gets the type of @value.

Returns: an FlValueType.

Definition at line 466 of file fl_value.cc.

                                                             {
  g_return_val_if_fail(self != nullptr, FL_VALUE_TYPE_NULL);
  return self->type;
}

fl_value_get_uint8_list()

G_MODULE_EXPORT const uint8_t * fl_value_get_uint8_list

(

FlValue *

value

)

fl_value_get_uint8_list: @value: an FlValue of type FL_VALUE_TYPE_UINT8_LIST.

Gets the array of unisigned 8 bit integers @value contains. The data contains fl_value_get_length() elements. Calling this with an FlValue that is not of type FL_VALUE_TYPE_UINT8_LIST is a programming error.

Returns: an array of unsigned 8 bit integers.

Definition at line 689 of file fl_value.cc.

                                                                      {
  g_return_val_if_fail(self != nullptr, nullptr);
  g_return_val_if_fail(self->type == FL_VALUE_TYPE_UINT8_LIST, nullptr);
  FlValueUint8List* v = reinterpret_cast<FlValueUint8List*>(self);
  return v->values;
}

fl_value_lookup()

G_MODULE_EXPORT FlValue * fl_value_lookup	(	FlValue *	value,
		FlValue *	key
	)

fl_value_lookup: @value: an FlValue of type FL_VALUE_TYPE_MAP. @key: a key value.

Gets the map entry that matches @key. Keys are checked using fl_value_equal(). Calling this with an FlValue that is not of type FL_VALUE_TYPE_MAP is a programming error.

Map lookups are not optimized for performance - if you have a large map or need frequent access you should copy the data into another structure, e.g. #GHashTable.

Returns: (allow-none): the value with this key or NULL if not one present.

Definition at line 800 of file fl_value.cc.

                                                                      {
  g_return_val_if_fail(self != nullptr, nullptr);
  g_return_val_if_fail(self->type == FL_VALUE_TYPE_MAP, nullptr);
 
  ssize_t index = fl_value_lookup_index(self, key);
  if (index < 0) {
    return nullptr;
  }
  return fl_value_get_map_value(self, index);
}

fl_value_lookup_index()

static ssize_t fl_value_lookup_index ( FlValue *  self, FlValue *  key  )

static

Definition at line 99 of file fl_value.cc.

                                                                  {
  g_return_val_if_fail(self->type == FL_VALUE_TYPE_MAP, -1);
 
  for (size_t i = 0; i < fl_value_get_length(self); i++) {
    FlValue* k = fl_value_get_map_key(self, i);
    if (fl_value_equal(k, key)) {
      return i;
    }
  }
  return -1;
}

fl_value_lookup_string()

G_MODULE_EXPORT FlValue * fl_value_lookup_string	(	FlValue *	value,
		const gchar *	key
	)

fl_value_lookup_string: @value: an FlValue of type FL_VALUE_TYPE_MAP. @key: a key value.

Gets the map entry that matches @key. Keys are checked using fl_value_equal(). Calling this with an FlValue that is not of type FL_VALUE_TYPE_MAP is a programming error.

Map lookups are not optimized for performance - if you have a large map or need frequent access you should copy the data into another structure, e.g. #GHashTable.

Returns: (allow-none): the value with this key or NULL if not one present.

Definition at line 811 of file fl_value.cc.

                                                                  {
  g_return_val_if_fail(self != nullptr, nullptr);
  FlValue* string_key = fl_value_new_string(key);
  FlValue* value = fl_value_lookup(self, string_key);
  // Explicit unref used because the g_autoptr is triggering a false positive
  // with clang-tidy.
  fl_value_unref(string_key);
  return value;
}

fl_value_new()

static FlValue * fl_value_new ( FlValueType  type, size_t  size  )

static

Definition at line 84 of file fl_value.cc.

                                                            {
  FlValue* self = static_cast<FlValue*>(g_malloc0(size));
  self->type = type;
  self->ref_count = 1;
  return self;
}

fl_value_new_bool()

G_MODULE_EXPORT FlValue * fl_value_new_bool

(

bool

value

)

fl_value_new_bool: @value: the value.

Creates an FlValue that contains a boolean value. The equivalent Dart type is a bool.

Returns: a new FlValue.

Definition at line 255 of file fl_value.cc.

                                                       {
  FlValueBool* self = reinterpret_cast<FlValueBool*>(
      fl_value_new(FL_VALUE_TYPE_BOOL, sizeof(FlValueBool)));
  self->value = value ? true : false;
  return reinterpret_cast<FlValue*>(self);
}

fl_value_new_custom()

G_MODULE_EXPORT FlValue * fl_value_new_custom	(	int	type,
		gconstpointer	value,
		GDestroyNotify	destroy_notify
	)

fl_value_new_custom: @type: an ID for this type. @value: pointer to the custom value. @destroy_notify: function to call when @value is no longer required.

Creates a new custom data type. The Dart side of the channel must have equivalent custom code to access this object.

Returns: a new FlValue.

Definition at line 374 of file fl_value.cc.

                                                                            {
  FlValueCustom* self = reinterpret_cast<FlValueCustom*>(
      fl_value_new(FL_VALUE_TYPE_CUSTOM, sizeof(FlValueCustom)));
  self->type = type;
  self->value = value;
  self->destroy_notify = destroy_notify;
  return reinterpret_cast<FlValue*>(self);
}

fl_value_new_custom_object()

G_MODULE_EXPORT FlValue * fl_value_new_custom_object	(	int	type,
		GObject *	object
	)

fl_value_new_custom_object: @type: an ID for this type. @object: the custom object.

Creates a new custom data type. The Dart side of the channel must have equivalent custom code to access this object.

Returns: a new FlValue.

Definition at line 385 of file fl_value.cc.

                                                                               {
  return fl_value_new_custom(type, g_object_ref(object), g_object_unref);
}

fl_value_new_custom_object_take()

G_MODULE_EXPORT FlValue * fl_value_new_custom_object_take	(	int	type,
		GObject *	object
	)

fl_value_new_custom_object_take: @type: an ID for this type. @object: (transfer full): the custom object.

Creates a new custom data type. The Dart side of the channel must have equivalent custom code to access this object. Ownership of @object is taken.

Returns: a new FlValue.

Definition at line 389 of file fl_value.cc.

                                                                          {
  return fl_value_new_custom(type, object, g_object_unref);
}

fl_value_new_float()

G_MODULE_EXPORT FlValue * fl_value_new_float

(

double

value

)

fl_value_new_float: @value: the value.

Creates an FlValue that contains a floating point number. The equivalent Dart type is a num.

Returns: a new FlValue.

Definition at line 269 of file fl_value.cc.

                                                          {
  FlValueDouble* self = reinterpret_cast<FlValueDouble*>(
      fl_value_new(FL_VALUE_TYPE_FLOAT, sizeof(FlValueDouble)));
  self->value = value;
  return reinterpret_cast<FlValue*>(self);
}

fl_value_new_float32_list()

G_MODULE_EXPORT FlValue * fl_value_new_float32_list	(	const float *	value,
		size_t	value_length
	)

fl_value_new_float32_list: @value: an array of floating point numbers. @value_length: number of elements in @value.

Creates an ordered list containing 32 bit floating point numbers. The equivalent Dart type is a Float32List.

Returns: a new FlValue.

Definition at line 329 of file fl_value.cc.

                                                                       {
  FlValueFloat32List* self = reinterpret_cast<FlValueFloat32List*>(
      fl_value_new(FL_VALUE_TYPE_FLOAT32_LIST, sizeof(FlValueFloat32List)));
  self->values_length = data_length;
  self->values = static_cast<float*>(g_malloc(sizeof(float) * data_length));
  memcpy(self->values, data, sizeof(float) * data_length);
  return reinterpret_cast<FlValue*>(self);
}

fl_value_new_float_list()

G_MODULE_EXPORT FlValue * fl_value_new_float_list	(	const double *	value,
		size_t	value_length
	)

fl_value_new_float_list: @value: an array of floating point numbers. @value_length: number of elements in @value.

Creates an ordered list containing floating point numbers. The equivalent Dart type is a Float64List.

Returns: a new FlValue.

Definition at line 339 of file fl_value.cc.

                                                                     {
  FlValueFloatList* self = reinterpret_cast<FlValueFloatList*>(
      fl_value_new(FL_VALUE_TYPE_FLOAT_LIST, sizeof(FlValueFloatList)));
  self->values_length = data_length;
  self->values = static_cast<double*>(g_malloc(sizeof(double) * data_length));
  memcpy(self->values, data, sizeof(double) * data_length);
  return reinterpret_cast<FlValue*>(self);
}

fl_value_new_int()

G_MODULE_EXPORT FlValue * fl_value_new_int

(

int64_t

value

)

fl_value_new_int: @value: the value.

Creates an FlValue that contains an integer number. The equivalent Dart type is a num.

Returns: a new FlValue.

Definition at line 262 of file fl_value.cc.

                                                         {
  FlValueInt* self = reinterpret_cast<FlValueInt*>(
      fl_value_new(FL_VALUE_TYPE_INT, sizeof(FlValueInt)));
  self->value = value;
  return reinterpret_cast<FlValue*>(self);
}

fl_value_new_int32_list()

G_MODULE_EXPORT FlValue * fl_value_new_int32_list	(	const int32_t *	value,
		size_t	value_length
	)

fl_value_new_int32_list: @value: an array of signed 32 bit integers. @value_length: number of elements in @value.

Creates an ordered list containing 32 bit integers. The equivalent Dart type is a Int32List.

Returns: a new FlValue.

Definition at line 309 of file fl_value.cc.

                                                                     {
  FlValueInt32List* self = reinterpret_cast<FlValueInt32List*>(
      fl_value_new(FL_VALUE_TYPE_INT32_LIST, sizeof(FlValueInt32List)));
  self->values_length = data_length;
  self->values = static_cast<int32_t*>(g_malloc(sizeof(int32_t) * data_length));
  memcpy(self->values, data, sizeof(int32_t) * data_length);
  return reinterpret_cast<FlValue*>(self);
}

fl_value_new_int64_list()

G_MODULE_EXPORT FlValue * fl_value_new_int64_list	(	const int64_t *	value,
		size_t	value_length
	)

fl_value_new_int64_list: @value: an array of signed 64 bit integers. @value_length: number of elements in @value.

Creates an ordered list containing 64 bit integers. The equivalent Dart type is a Int64List.

Returns: a new FlValue.

Definition at line 319 of file fl_value.cc.

                                                                     {
  FlValueInt64List* self = reinterpret_cast<FlValueInt64List*>(
      fl_value_new(FL_VALUE_TYPE_INT64_LIST, sizeof(FlValueInt64List)));
  self->values_length = data_length;
  self->values = static_cast<int64_t*>(g_malloc(sizeof(int64_t) * data_length));
  memcpy(self->values, data, sizeof(int64_t) * data_length);
  return reinterpret_cast<FlValue*>(self);
}

fl_value_new_list()

G_MODULE_EXPORT FlValue * fl_value_new_list

(

)

fl_value_new_list:

Creates an ordered list. Children can be added to the list using fl_value_append(). The children are accessed using fl_value_get_length() and fl_value_get_list_value(). The equivalent Dart type is a List<dynamic>.

The following example shows a simple list of values:

|[ g_autoptr(FlValue) value = fl_value_new_list (); fl_value_append_take (value, fl_value_new_string ("one"); fl_value_append_take (value, fl_value_new_int (2); fl_value_append_take (value, fl_value_new_float (3.0); ]|

This value can be decoded using:

|[ g_assert (fl_value_get_type (value) == FL_VALUE_TYPE_LIST); for (size_t i = 0; i < fl_value_get_length (value); i++) { FlValue *child = fl_value_get_list_value (value, i); process_value (child); } ]|

Returns: a new FlValue.

Definition at line 349 of file fl_value.cc.

                                             {
  FlValueList* self = reinterpret_cast<FlValueList*>(
      fl_value_new(FL_VALUE_TYPE_LIST, sizeof(FlValueList)));
  self->values = g_ptr_array_new_with_free_func(fl_value_destroy);
  return reinterpret_cast<FlValue*>(self);
}

fl_value_new_list_from_strv()

G_MODULE_EXPORT FlValue * fl_value_new_list_from_strv

(

const gchar *const *

value

)

fl_value_new_list_from_strv: @value: a NULL-terminated array of strings.

Creates an ordered list containing #FlString values.

Returns: a new FlValue.

Definition at line 356 of file fl_value.cc.

                                   {
  g_return_val_if_fail(str_array != nullptr, nullptr);
  g_autoptr(FlValue) value = fl_value_new_list();
  for (int i = 0; str_array[i] != nullptr; i++) {
    fl_value_append_take(value, fl_value_new_string(str_array[i]));
  }
  return fl_value_ref(value);
}

fl_value_new_map()

G_MODULE_EXPORT FlValue * fl_value_new_map

(

)

fl_value_new_map:

Creates an ordered associative array. Children can be added to the map using fl_value_set(), fl_value_set_take(), fl_value_set_string(), fl_value_set_string_take(). The children are accessed using fl_value_get_length(), fl_value_get_map_key(), fl_value_get_map_value(), fl_value_lookup() and fl_value_lookup_string(). The equivalent Dart type is a Map<dynamic>.

The following example shows how to create a map of values keyed by strings:

|[ g_autoptr(FlValue) value = fl_value_new_map (); fl_value_set_string_take (value, "name", fl_value_new_string ("Gandalf")); fl_value_set_string_take (value, "occupation", fl_value_new_string ("Wizard")); fl_value_set_string_take (value, "age", fl_value_new_int (2019)); ]|

This value can be decoded using: |[ g_assert (fl_value_get_type (value) == FL_VALUE_TYPE_MAP); FlValue *name = fl_value_lookup_string (value, "name"); g_assert (fl_value_get_type (name) == FL_VALUE_TYPE_STRING); FlValue *age = fl_value_lookup_string (value, "age"); g_assert (fl_value_get_type (age) == FL_VALUE_TYPE_INT); g_message ("Next customer is %s (%d years old)", fl_value_get_string (name), fl_value_get_int (age)); ]|

Returns: a new FlValue.

Definition at line 366 of file fl_value.cc.

                                            {
  FlValueMap* self = reinterpret_cast<FlValueMap*>(
      fl_value_new(FL_VALUE_TYPE_MAP, sizeof(FlValueMap)));
  self->keys = g_ptr_array_new_with_free_func(fl_value_destroy);
  self->values = g_ptr_array_new_with_free_func(fl_value_destroy);
  return reinterpret_cast<FlValue*>(self);
}

fl_value_new_null()

G_MODULE_EXPORT FlValue * fl_value_new_null

(

)

fl_value_new_null:

Creates an FlValue that contains a null value. The equivalent Dart type is null.

Returns: a new FlValue.

Definition at line 251 of file fl_value.cc.

                                             {
  return fl_value_new(FL_VALUE_TYPE_NULL, sizeof(FlValue));
}

fl_value_new_string()

G_MODULE_EXPORT FlValue * fl_value_new_string

(

const gchar *

value

)

fl_value_new_string: @value: a NULL-terminated UTF-8 string.

Creates an FlValue that contains UTF-8 text. The equivalent Dart type is a String.

Returns: a new FlValue.

Definition at line 276 of file fl_value.cc.

                                                                 {
  FlValueString* self = reinterpret_cast<FlValueString*>(
      fl_value_new(FL_VALUE_TYPE_STRING, sizeof(FlValueString)));
  self->value = g_strdup(value);
  return reinterpret_cast<FlValue*>(self);
}

fl_value_new_string_sized()

G_MODULE_EXPORT FlValue * fl_value_new_string_sized	(	const gchar *	value,
		size_t	value_length
	)

fl_value_new_string_sized: @value: a buffer containing UTF-8 text. It does not require a nul terminator. @value_length: the number of bytes to use from @value.

Creates an FlValue that contains UTF-8 text. The equivalent Dart type is a String.

Returns: a new FlValue.

Definition at line 283 of file fl_value.cc.

                                                                        {
  FlValueString* self = reinterpret_cast<FlValueString*>(
      fl_value_new(FL_VALUE_TYPE_STRING, sizeof(FlValueString)));
  self->value =
      value_length == 0 ? g_strdup("") : g_strndup(value, value_length);
  return reinterpret_cast<FlValue*>(self);
}

fl_value_new_uint8_list()

G_MODULE_EXPORT FlValue * fl_value_new_uint8_list	(	const uint8_t *	value,
		size_t	value_length
	)

fl_value_new_uint8_list: @value: an array of unsigned 8 bit integers. @value_length: number of elements in @value.

Creates an ordered list containing 8 bit unsigned integers. The data is copied. The equivalent Dart type is a Uint8List.

Returns: a new FlValue.

Definition at line 292 of file fl_value.cc.

                                                                     {
  FlValueUint8List* self = reinterpret_cast<FlValueUint8List*>(
      fl_value_new(FL_VALUE_TYPE_UINT8_LIST, sizeof(FlValueUint8List)));
  self->values_length = data_length;
  self->values = static_cast<uint8_t*>(g_malloc(sizeof(uint8_t) * data_length));
  memcpy(self->values, data, sizeof(uint8_t) * data_length);
  return reinterpret_cast<FlValue*>(self);
}

fl_value_new_uint8_list_from_bytes()

G_MODULE_EXPORT FlValue * fl_value_new_uint8_list_from_bytes

(

GBytes *

value

)

fl_value_new_uint8_list_from_bytes: @value: a #GBytes.

Creates an ordered list containing 8 bit unsigned integers. The data is copied. The equivalent Dart type is a Uint8List.

Returns: a new FlValue.

Definition at line 302 of file fl_value.cc.

                                                                          {
  gsize length;
  const uint8_t* d =
      static_cast<const uint8_t*>(g_bytes_get_data(data, &length));
  return fl_value_new_uint8_list(d, length);
}

fl_value_ref()

G_MODULE_EXPORT FlValue * fl_value_ref

(

FlValue *

value

)

fl_value_ref: @value: an FlValue.

Increases the reference count of an FlValue.

Returns: the value that was referenced.

Definition at line 394 of file fl_value.cc.

                                                     {
  g_return_val_if_fail(self != nullptr, nullptr);
  self->ref_count++;
  return self;
}

fl_value_set()

G_MODULE_EXPORT void fl_value_set	(	FlValue *	value,
		FlValue *	key,
		FlValue *	child_value
	)

fl_value_set: @value: an FlValue of type FL_VALUE_TYPE_MAP. @key: an FlValue. @child_value: an FlValue.

Sets @key in @value to @child_value. If an existing value was in the map with the same key it is replaced. Calling this with an FlValue that is not of type FL_VALUE_TYPE_MAP is a programming error.

Definition at line 609 of file fl_value.cc.

                                                                               {
  g_return_if_fail(self != nullptr);
  g_return_if_fail(self->type == FL_VALUE_TYPE_MAP);
  g_return_if_fail(key != nullptr);
  g_return_if_fail(value != nullptr);
 
  fl_value_set_take(self, fl_value_ref(key), fl_value_ref(value));
}

fl_value_set_string()

G_MODULE_EXPORT void fl_value_set_string	(	FlValue *	value,
		const gchar *	key,
		FlValue *	child_value
	)

fl_value_set_string: @value: an FlValue of type FL_VALUE_TYPE_MAP. @key: a UTF-8 text key. @child_value: an FlValue.

Sets a value in the map with a text key. If an existing value was in the map with the same key it is replaced. Calling this with an FlValue that is not of type FL_VALUE_TYPE_MAP is a programming error.

Definition at line 639 of file fl_value.cc.

                                                         {
  g_return_if_fail(self != nullptr);
  g_return_if_fail(self->type == FL_VALUE_TYPE_MAP);
  g_return_if_fail(key != nullptr);
  g_return_if_fail(value != nullptr);
 
  fl_value_set_take(self, fl_value_new_string(key), fl_value_ref(value));
}

fl_value_set_string_take()

G_MODULE_EXPORT void fl_value_set_string_take	(	FlValue *	value,
		const gchar *	key,
		FlValue *	child_value
	)

fl_value_set_string_take: @value: an FlValue of type FL_VALUE_TYPE_MAP. @key: a UTF-8 text key. @child_value: (transfer full): an FlValue.

Sets a value in the map with a text key, taking ownership of the value. If an existing value was in the map with the same key it is replaced. Calling this with an FlValue that is not of type FL_VALUE_TYPE_MAP is a programming error.

Definition at line 650 of file fl_value.cc.

                                                              {
  g_return_if_fail(self != nullptr);
  g_return_if_fail(self->type == FL_VALUE_TYPE_MAP);
  g_return_if_fail(key != nullptr);
  g_return_if_fail(value != nullptr);
 
  fl_value_set_take(self, fl_value_new_string(key), value);
}

fl_value_set_take()

G_MODULE_EXPORT void fl_value_set_take	(	FlValue *	value,
		FlValue *	key,
		FlValue *	child_value
	)

fl_value_set_take: @value: an FlValue of type FL_VALUE_TYPE_MAP. @key: (transfer full): an FlValue. @child_value: (transfer full): an FlValue.

Sets @key in @value to @child_value. Ownership of both @key and @child_value is taken by @value. If an existing value was in the map with the same key it is replaced. Calling this with an FlValue that is not of type FL_VALUE_TYPE_MAP is a programming error.

Definition at line 618 of file fl_value.cc.

                                                       {
  g_return_if_fail(self != nullptr);
  g_return_if_fail(self->type == FL_VALUE_TYPE_MAP);
  g_return_if_fail(key != nullptr);
  g_return_if_fail(value != nullptr);
 
  FlValueMap* v = reinterpret_cast<FlValueMap*>(self);
  ssize_t index = fl_value_lookup_index(self, key);
  if (index < 0) {
    g_ptr_array_add(v->keys, key);
    g_ptr_array_add(v->values, value);
  } else {
    fl_value_destroy(v->keys->pdata[index]);
    v->keys->pdata[index] = key;
    fl_value_destroy(v->values->pdata[index]);
    v->values->pdata[index] = value;
  }
}

fl_value_to_string()

G_MODULE_EXPORT gchar * fl_value_to_string

(

FlValue *

value

)

fl_value_to_string: @value: an FlValue.

Converts an FlValue to a text representation, suitable for logging purposes. The text is formatted to be the equivalent of Dart toString() methods.

Returns: UTF-8 text.

Definition at line 846 of file fl_value.cc.

                                                          {
  GString* buffer = g_string_new("");
  value_to_string(value, buffer);
  return g_string_free(buffer, FALSE);
}

fl_value_unref()

G_MODULE_EXPORT void fl_value_unref

(

FlValue *

value

)

fl_value_unref: @value: an FlValue.

Decreases the reference count of an FlValue. When the reference count hits zero @value is destroyed and no longer valid.

Definition at line 400 of file fl_value.cc.

                                                   {
  g_return_if_fail(self != nullptr);
  g_return_if_fail(self->ref_count > 0);
  self->ref_count--;
  if (self->ref_count != 0) {
    return;
  }
 
  switch (self->type) {
    case FL_VALUE_TYPE_STRING: {
      FlValueString* v = reinterpret_cast<FlValueString*>(self);
      g_free(v->value);
      break;
    }
    case FL_VALUE_TYPE_UINT8_LIST: {
      FlValueUint8List* v = reinterpret_cast<FlValueUint8List*>(self);
      g_free(v->values);
      break;
    }
    case FL_VALUE_TYPE_INT32_LIST: {
      FlValueInt32List* v = reinterpret_cast<FlValueInt32List*>(self);
      g_free(v->values);
      break;
    }
    case FL_VALUE_TYPE_INT64_LIST: {
      FlValueInt64List* v = reinterpret_cast<FlValueInt64List*>(self);
      g_free(v->values);
      break;
    }
    case FL_VALUE_TYPE_FLOAT32_LIST: {
      FlValueFloat32List* v = reinterpret_cast<FlValueFloat32List*>(self);
      g_free(v->values);
      break;
    }
    case FL_VALUE_TYPE_FLOAT_LIST: {
      FlValueFloatList* v = reinterpret_cast<FlValueFloatList*>(self);
      g_free(v->values);
      break;
    }
    case FL_VALUE_TYPE_LIST: {
      FlValueList* v = reinterpret_cast<FlValueList*>(self);
      g_ptr_array_unref(v->values);
      break;
    }
    case FL_VALUE_TYPE_MAP: {
      FlValueMap* v = reinterpret_cast<FlValueMap*>(self);
      g_ptr_array_unref(v->keys);
      g_ptr_array_unref(v->values);
      break;
    }
    case FL_VALUE_TYPE_CUSTOM: {
      FlValueCustom* v = reinterpret_cast<FlValueCustom*>(self);
      if (v->destroy_notify != nullptr) {
        v->destroy_notify((gpointer)v->value);
      }
      break;
    }
    case FL_VALUE_TYPE_NULL:
    case FL_VALUE_TYPE_BOOL:
    case FL_VALUE_TYPE_INT:
    case FL_VALUE_TYPE_FLOAT:
      break;
  }
  g_free(self);
}

float_to_string()

static void float_to_string ( double  value, GString *  buffer  )

static

Definition at line 117 of file fl_value.cc.

                                                           {
  g_string_append_printf(buffer, "%.16f", value);
 
  // Strip trailing zeros.
  int zero_count = 0;
  for (int i = buffer->len - 1; i >= 0; i--) {
    // Leave one zero after a decimal point.
    if (buffer->str[i] == '.') {
      zero_count = zero_count == 0 ? 0 : zero_count - 1;
      break;
    }
    if (buffer->str[i] != '0') {
      break;
    }
    zero_count++;
  }
  g_string_truncate(buffer, buffer->len - zero_count);
}

int_to_string()

static void int_to_string ( int64_t  value, GString *  buffer  )

static

Definition at line 112 of file fl_value.cc.

                                                          {
  g_string_append_printf(buffer, "%" G_GINT64_FORMAT, value);
}

value_to_string()

static void value_to_string ( FlValue *  value, GString *  buffer  )

static

Definition at line 136 of file fl_value.cc.

                                                             {
  switch (value->type) {
    case FL_VALUE_TYPE_NULL:
      g_string_append(buffer, "null");
      return;
    case FL_VALUE_TYPE_BOOL:
      if (fl_value_get_bool(value)) {
        g_string_append(buffer, "true");
      } else {
        g_string_append(buffer, "false");
      }
      return;
    case FL_VALUE_TYPE_INT:
      int_to_string(fl_value_get_int(value), buffer);
      return;
    case FL_VALUE_TYPE_FLOAT:
      float_to_string(fl_value_get_float(value), buffer);
      return;
    case FL_VALUE_TYPE_STRING: {
      g_string_append(buffer, fl_value_get_string(value));
      return;
    }
    case FL_VALUE_TYPE_UINT8_LIST: {
      g_string_append(buffer, "[");
      const uint8_t* values = fl_value_get_uint8_list(value);
      for (size_t i = 0; i < fl_value_get_length(value); i++) {
        if (i != 0) {
          g_string_append(buffer, ", ");
        }
        int_to_string(values[i], buffer);
      }
      g_string_append(buffer, "]");
      return;
    }
    case FL_VALUE_TYPE_INT32_LIST: {
      g_string_append(buffer, "[");
      const int32_t* values = fl_value_get_int32_list(value);
      for (size_t i = 0; i < fl_value_get_length(value); i++) {
        if (i != 0) {
          g_string_append(buffer, ", ");
        }
        int_to_string(values[i], buffer);
      }
      g_string_append(buffer, "]");
      return;
    }
    case FL_VALUE_TYPE_INT64_LIST: {
      g_string_append(buffer, "[");
      const int64_t* values = fl_value_get_int64_list(value);
      for (size_t i = 0; i < fl_value_get_length(value); i++) {
        if (i != 0) {
          g_string_append(buffer, ", ");
        }
        int_to_string(values[i], buffer);
      }
      g_string_append(buffer, "]");
      return;
    }
    case FL_VALUE_TYPE_FLOAT32_LIST: {
      g_string_append(buffer, "[");
      const float* values = fl_value_get_float32_list(value);
      for (size_t i = 0; i < fl_value_get_length(value); i++) {
        if (i != 0) {
          g_string_append(buffer, ", ");
        }
        float_to_string(values[i], buffer);
      }
      g_string_append(buffer, "]");
      return;
    }
    case FL_VALUE_TYPE_FLOAT_LIST: {
      g_string_append(buffer, "[");
      const double* values = fl_value_get_float_list(value);
      for (size_t i = 0; i < fl_value_get_length(value); i++) {
        if (i != 0) {
          g_string_append(buffer, ", ");
        }
        float_to_string(values[i], buffer);
      }
      g_string_append(buffer, "]");
      return;
    }
    case FL_VALUE_TYPE_LIST: {
      g_string_append(buffer, "[");
      for (size_t i = 0; i < fl_value_get_length(value); i++) {
        if (i != 0) {
          g_string_append(buffer, ", ");
        }
        value_to_string(fl_value_get_list_value(value, i), buffer);
      }
      g_string_append(buffer, "]");
      return;
    }
    case FL_VALUE_TYPE_MAP: {
      g_string_append(buffer, "{");
      for (size_t i = 0; i < fl_value_get_length(value); i++) {
        if (i != 0) {
          g_string_append(buffer, ", ");
        }
        value_to_string(fl_value_get_map_key(value, i), buffer);
        g_string_append(buffer, ": ");
        value_to_string(fl_value_get_map_value(value, i), buffer);
      }
      g_string_append(buffer, "}");
      return;
    }
    case FL_VALUE_TYPE_CUSTOM:
      g_string_append_printf(buffer, "(custom %d)",
                             fl_value_get_custom_type(value));
      return;
    default:
      g_string_append_printf(buffer, "<unknown type %d>", value->type);
  }
}