#include <glib-object.h>
#include <glib.h>
#include <stdbool.h>
#include <stdint.h>

Typedefs
typedef typedefG_BEGIN_DECLS struct _FlValue	FlValue

Enumerations
enum	FlValueType { FL_VALUE_TYPE_NULL , FL_VALUE_TYPE_BOOL , FL_VALUE_TYPE_INT , FL_VALUE_TYPE_FLOAT , FL_VALUE_TYPE_STRING , FL_VALUE_TYPE_UINT8_LIST , FL_VALUE_TYPE_INT32_LIST , FL_VALUE_TYPE_INT64_LIST , FL_VALUE_TYPE_FLOAT_LIST , FL_VALUE_TYPE_LIST , FL_VALUE_TYPE_MAP , FL_VALUE_TYPE_FLOAT32_LIST , FL_VALUE_TYPE_CUSTOM }

Functions
FlValue *	fl_value_new_null ()

FlValue *	fl_value_new_bool (bool value)

FlValue *	fl_value_new_int (int64_t value)

FlValue *	fl_value_new_float (double value)

FlValue *	fl_value_new_string (const gchar *value)

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

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

FlValue *	fl_value_new_uint8_list_from_bytes (GBytes *value)

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

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

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

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

FlValue *	fl_value_new_list ()

FlValue *	fl_value_new_list_from_strv (const gchar const value)

FlValue *	fl_value_new_map ()

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

FlValue *	fl_value_new_custom_object (int type, GObject *object)

FlValue *	fl_value_new_custom_object_take (int type, GObject *object)

FlValue *	fl_value_ref (FlValue *value)

void	fl_value_unref (FlValue *value)

FlValueType	fl_value_get_type (FlValue *value)

bool	fl_value_equal (FlValue a, FlValue b)

void	fl_value_append (FlValue value, FlValue child)

void	fl_value_append_take (FlValue value, FlValue child)

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

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

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

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

bool	fl_value_get_bool (FlValue *value)

int64_t	fl_value_get_int (FlValue *value)

double	fl_value_get_float (FlValue *value)

const gchar *	fl_value_get_string (FlValue *value)

size_t	fl_value_get_length (FlValue *value)

const uint8_t *	fl_value_get_uint8_list (FlValue *value)

const int32_t *	fl_value_get_int32_list (FlValue *value)

const int64_t *	fl_value_get_int64_list (FlValue *value)

const float *	fl_value_get_float32_list (FlValue *value)

const double *	fl_value_get_float_list (FlValue *value)

FlValue *	fl_value_get_list_value (FlValue *value, size_t index)

FlValue *	fl_value_get_map_key (FlValue *value, size_t index)

FlValue *	fl_value_get_map_value (FlValue *value, size_t index)

FlValue *	fl_value_lookup (FlValue value, FlValue key)

FlValue *	fl_value_lookup_string (FlValue value, const gchar key)

int	fl_value_get_custom_type (FlValue *value)

gconstpointer	fl_value_get_custom_value (FlValue *value)

GObject *	fl_value_get_custom_value_object (FlValue *value)

gchar *	fl_value_to_string (FlValue *value)

Typedef Documentation

◆ FlValue

typedef typedefG_BEGIN_DECLS struct _FlValue FlValue

FlValue:

FlValue is an object that contains the data types used in the platform channel used by Flutter.

In Dart the values are represented as follows:

See #FlMessageCodec to encode and decode these values.

Definition at line 42 of file fl_value.h.

Enumeration Type Documentation

◆ FlValueType

enum FlValueType

FlValueType: @FL_VALUE_TYPE_NULL: The null value. @FL_VALUE_TYPE_BOOL: A boolean. @FL_VALUE_TYPE_INT: A 64 bit signed integer. @FL_VALUE_TYPE_FLOAT: A 64 bit floating point number. @FL_VALUE_TYPE_STRING: UTF-8 text. @FL_VALUE_TYPE_UINT8_LIST: An ordered list of unsigned 8 bit integers. @FL_VALUE_TYPE_INT32_LIST: An ordered list of 32 bit integers. @FL_VALUE_TYPE_INT64_LIST: An ordered list of 64 bit integers. @FL_VALUE_TYPE_FLOAT_LIST: An ordered list of floating point numbers. @FL_VALUE_TYPE_LIST: An ordered list of FlValue objects. @FL_VALUE_TYPE_MAP: A map of FlValue objects keyed by FlValue object. @FL_VALUE_TYPE_FLOAT32_LIST: An ordered list of 32bit floating point numbers. @FL_VALUE_TYPE_CUSTOM: A custom value.

Types of FlValue.

Enumerator
FL_VALUE_TYPE_NULL
FL_VALUE_TYPE_BOOL
FL_VALUE_TYPE_INT
FL_VALUE_TYPE_FLOAT
FL_VALUE_TYPE_STRING
FL_VALUE_TYPE_UINT8_LIST
FL_VALUE_TYPE_INT32_LIST
FL_VALUE_TYPE_INT64_LIST
FL_VALUE_TYPE_FLOAT_LIST
FL_VALUE_TYPE_LIST
FL_VALUE_TYPE_MAP
FL_VALUE_TYPE_FLOAT32_LIST
FL_VALUE_TYPE_CUSTOM

Definition at line 62 of file fl_value.h.

             {
  // Parts of the public API, so fixing the names is a breaking change.
  // NOLINTBEGIN(readability-identifier-naming)
  FL_VALUE_TYPE_NULL,
  FL_VALUE_TYPE_BOOL,
  FL_VALUE_TYPE_INT,
  FL_VALUE_TYPE_FLOAT,
  FL_VALUE_TYPE_STRING,
  FL_VALUE_TYPE_UINT8_LIST,
  FL_VALUE_TYPE_INT32_LIST,
  FL_VALUE_TYPE_INT64_LIST,
  FL_VALUE_TYPE_FLOAT_LIST,
  FL_VALUE_TYPE_LIST,
  FL_VALUE_TYPE_MAP,
  FL_VALUE_TYPE_FLOAT32_LIST,
  FL_VALUE_TYPE_CUSTOM,
  // NOLINTEND(readability-identifier-naming)
} FlValueType;

Function Documentation

◆ fl_value_append()

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()

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_equal()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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_string()

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_bool()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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

Typedefs

Enumerations

Functions

Typedef Documentation

◆ FlValue

Enumeration Type Documentation

◆ FlValueType

Function Documentation

◆ fl_value_append()

◆ fl_value_append_take()

◆ fl_value_equal()

◆ fl_value_get_bool()

◆ fl_value_get_custom_type()

◆ fl_value_get_custom_value()

◆ fl_value_get_custom_value_object()

◆ 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_lookup()

◆ fl_value_lookup_string()

◆ fl_value_new_bool()

◆ fl_value_new_custom()

◆ fl_value_new_custom_object()

◆ fl_value_new_custom_object_take()

◆ fl_value_new_float()

◆ fl_value_new_float32_list()

◆ fl_value_new_float_list()

◆ fl_value_new_int()

◆ fl_value_new_int32_list()

◆ fl_value_new_int64_list()

◆ fl_value_new_list()

◆ fl_value_new_list_from_strv()

◆ fl_value_new_map()

◆ fl_value_new_null()

◆ fl_value_new_string()

◆ fl_value_new_string_sized()

◆ fl_value_new_uint8_list()

◆ fl_value_new_uint8_list_from_bytes()

◆ fl_value_ref()

◆ fl_value_set()

◆ fl_value_set_string()

◆ fl_value_set_string_take()

◆ fl_value_set_take()

◆ fl_value_to_string()

◆ fl_value_unref()