654 lines
28 KiB
Cython
654 lines
28 KiB
Cython
|
|
|
|
#define EET_T_UNKNOW 0 # Unknown data encoding type
|
|
#define EET_T_CHAR 1 # Data type: char
|
|
#define EET_T_SHORT 2 # Data type: short
|
|
#define EET_T_INT 3 # Data type: int
|
|
#define EET_T_LONG_LONG 4 # Data type: long long
|
|
#define EET_T_FLOAT 5 # Data type: float
|
|
#define EET_T_DOUBLE 6 # Data type: double
|
|
#define EET_T_UCHAR 7 # Data type: unsigned char
|
|
#define EET_T_USHORT 8 # Data type: unsigned short
|
|
#define EET_T_UINT 9 # Data type: unsigned int
|
|
#define EET_T_ULONG_LONG 10 # Data type: unsigned long long
|
|
#define EET_T_STRING 11 # Data type: char *
|
|
#define EET_T_INLINED_STRING 12 # Data type: char * (but compressed inside the resulting eet)
|
|
#define EET_T_NULL 13 # Data type: (void *) (only use it if you know why)
|
|
#define EET_T_F32P32 14 # Data type: fixed point 32.32
|
|
#define EET_T_F16P16 15 # Data type: fixed point 16.16
|
|
#define EET_T_F8P24 16 # Data type: fixed point 8.24
|
|
#define EET_T_VALUE 17 # Data type: pointer to Eina_Value :since: 1.8
|
|
#define EET_T_LAST 18 # Last data type
|
|
|
|
#define EET_G_UNKNOWN 100 # Unknown group data encoding type
|
|
#define EET_G_ARRAY 101 # Fixed size array group type
|
|
#define EET_G_VAR_ARRAY 102 # Variable size array group type
|
|
#define EET_G_LIST 103 # Linked list group type
|
|
#define EET_G_HASH 104 # Hash table group type
|
|
#define EET_G_UNION 105 # Union group type
|
|
#define EET_G_VARIANT 106 # Selectable subtype group
|
|
#define EET_G_UNKNOWN_NESTED 107 # Unknown nested group type. :since: 1.8
|
|
#define EET_G_LAST 108 # Last group type
|
|
|
|
#define EET_I_LIMIT 128 # Other type exist but are reserved for internal purpose.
|
|
|
|
|
|
cdef class EetDataDescriptor(object):
|
|
|
|
"""
|
|
|
|
Opaque handle that have information on a type members.
|
|
|
|
Descriptors are created using an #Eet_Data_Descriptor_Class, and they
|
|
describe the contents of the structure that will be serialized by Eet.
|
|
Not all members need be described by it, just those that should be handled
|
|
by Eet. This way it's possible to have one structure with both data to be
|
|
saved to a file, like application configuration, and runtime information
|
|
that would be meaningless to store, but is appropriate to keep together
|
|
during the program execution.
|
|
The members are added by means of
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(), EET_DATA_DESCRIPTOR_ADD_SUB(),
|
|
EET_DATA_DESCRIPTOR_ADD_LIST(), EET_DATA_DESCRIPTOR_ADD_HASH()
|
|
or eet_data_descriptor_element_add().
|
|
|
|
:see: eet_data_descriptor_stream_new()
|
|
:see: eet_data_descriptor_file_new()
|
|
:see: eet_data_descriptor_free()
|
|
|
|
"""
|
|
|
|
cdef Eet_Data_Descriptor *edd
|
|
|
|
def __init__(self, cls):
|
|
"""
|
|
|
|
This function creates a new data descriptor and returns a handle to the
|
|
new data descriptor. On creation it will be empty, containing no
|
|
contents describing anything other than the shell of the data structure.
|
|
:param eddc: The class from where to create the data descriptor.
|
|
:return: A handle to the new data descriptor.
|
|
|
|
You add structure members to the data descriptor using the macros
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(), EET_DATA_DESCRIPTOR_ADD_SUB() and
|
|
EET_DATA_DESCRIPTOR_ADD_LIST(), depending on what type of member you are
|
|
adding to the description.
|
|
|
|
Once you have described all the members of a struct you want loaded or
|
|
saved, eet can load and save those members for you, encode them into
|
|
endian-independent serialised data chunks for transmission across a
|
|
network or more.
|
|
|
|
This function specially ignores str_direct_alloc and str_direct_free. It
|
|
is useful when the eet_data you are reading doesn't have a dictionary,
|
|
like network stream or IPC. It also mean that all string will be
|
|
allocated and duplicated in memory.
|
|
|
|
:since: 1.2.3
|
|
|
|
"""
|
|
self.edd = eet_data_descriptor_stream_new(cls.eddc)
|
|
|
|
def file_new(self, cls):
|
|
"""
|
|
|
|
This function creates a new data descriptor and returns a handle to the
|
|
new data descriptor. On creation it will be empty, containing no
|
|
contents describing anything other than the shell of the data structure.
|
|
:param eddc: The class from where to create the data descriptor.
|
|
:return: A handle to the new data descriptor.
|
|
|
|
You add structure members to the data descriptor using the macros
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(), EET_DATA_DESCRIPTOR_ADD_SUB() and
|
|
EET_DATA_DESCRIPTOR_ADD_LIST(), depending on what type of member you are
|
|
adding to the description.
|
|
|
|
Once you have described all the members of a struct you want loaded or
|
|
saved, eet can load and save those members for you, encode them into
|
|
endian-independent serialised data chunks for transmission across a
|
|
a network or more.
|
|
|
|
This function uses str_direct_alloc and str_direct_free. It is useful
|
|
when the eet_data you are reading come from a file and have a
|
|
dictionary. This will reduce memory use and improve the possibility for
|
|
the OS to page this string out.
|
|
|
|
However, the load speed and memory saving comes with some drawbacks to
|
|
keep in mind. If you never modify the contents of the structures loaded
|
|
from the file, all you need to remember is that closing the eet file
|
|
will make the strings go away. On the other hand, should you need to
|
|
free a string, before doing so you have to verify that it's not part of
|
|
the eet dictionary. You can do this in the following way, assuming @p ef
|
|
is a valid Eet_File and @p str is a string loaded from said file.
|
|
|
|
@code
|
|
void eet_string_free(Eet_File *ef, const char *str)
|
|
{
|
|
Eet_Dictionary *dict = eet_dictionary_get(ef);
|
|
if (dict && eet_dictionary_string_check(dict, str))
|
|
{
|
|
// The file contains a dictionary and the given string is a part of
|
|
// of it, so we can't free it, just return.
|
|
return;
|
|
}
|
|
// We assume eina_stringshare was used on the descriptor
|
|
eina_stringshare_del(str);
|
|
}
|
|
@endcode
|
|
|
|
:since: 1.2.3
|
|
|
|
"""
|
|
self.edd = eet_data_descriptor_file_new(cls.eddc)
|
|
|
|
def free(self):
|
|
"""
|
|
|
|
This function frees a data descriptor when it is not needed anymore.
|
|
:param edd: The data descriptor to free.
|
|
|
|
This function takes a data descriptor handle as a parameter and frees all
|
|
data allocated for the data descriptor and the handle itself. After this
|
|
call the descriptor is no longer valid.
|
|
|
|
:since: 1.0.0
|
|
|
|
"""
|
|
eet_data_descriptor_free(self.edd)
|
|
|
|
property name:
|
|
"""
|
|
|
|
This function returns the name of a data descriptor.
|
|
|
|
:since: 1.8.0
|
|
|
|
"""
|
|
return _ctouni(eet_data_descriptor_name_get(self.edd)
|
|
|
|
|
|
def decode(self, data_in, size_in):
|
|
"""
|
|
|
|
Decode a data structure from an arbitrary location in memory.
|
|
:param edd: The data descriptor to use when decoding.
|
|
:param data_in: The pointer to the data to decode into a struct.
|
|
:param size_in: The size of the data pointed to in bytes.
|
|
:return: NULL on failure, or a valid decoded struct pointer on success.
|
|
|
|
This function will decode a data structure that has been encoded using
|
|
eet_data_descriptor_encode(), and return a data structure with all its
|
|
elements filled out, if successful, or NULL on failure.
|
|
|
|
The data to be decoded is stored at the memory pointed to by @p data_in,
|
|
and is described by the descriptor pointed to by @p edd. The data size is
|
|
passed in as the value to @p size_in, ande must be greater than 0 to
|
|
succeed.
|
|
|
|
This function is useful for decoding data structures delivered to the
|
|
application by means other than an eet file, such as an IPC or socket
|
|
connection, raw files, shared memory etc.
|
|
|
|
Please see eet_data_read() for more information.
|
|
|
|
@see eet_data_descriptor_decode_cipher()
|
|
|
|
:since: 1.0.0
|
|
|
|
"""
|
|
EAPI void *
|
|
eet_data_descriptor_decode(Eet_Data_Descriptor *edd,
|
|
const void *data_in,
|
|
int size_in);
|
|
|
|
def encode(self, data_in):
|
|
"""
|
|
|
|
Encode a dsata struct to memory and return that encoded data.
|
|
:param edd: The data descriptor to use when encoding.
|
|
:param data_in: The pointer to the struct to encode into data.
|
|
:param size_ret: pointer to the an int to be filled with the decoded size.
|
|
:return: NULL on failure, or a valid encoded data chunk on success.
|
|
|
|
This function takes a data structutre in memory and encodes it into a
|
|
serialised chunk of data that can be decoded again by
|
|
eet_data_descriptor_decode(). This is useful for being able to transmit
|
|
data structures across sockets, pipes, IPC or shared file mechanisms,
|
|
without having to worry about memory space, machine type, endianness etc.
|
|
|
|
The parameter @p edd must point to a valid data descriptor, and
|
|
@p data_in must point to the right data structure to encode. If not, the
|
|
encoding may fail.
|
|
|
|
On success a non NULL valid pointer is returned and what @p size_ret
|
|
points to is set to the size of this decoded data, in bytes. When the
|
|
encoded data is no longer needed, call free() on it. On failure NULL is
|
|
returned and what @p size_ret points to is set to 0.
|
|
|
|
Please see eet_data_write() for more information.
|
|
|
|
@see eet_data_descriptor_encode_cipher()
|
|
|
|
:since: 1.0.0
|
|
|
|
"""
|
|
EAPI void *
|
|
eet_data_descriptor_encode(Eet_Data_Descriptor *edd,
|
|
const void *data_in,
|
|
int *size_ret);
|
|
|
|
def decode_cipher(self, data_in, cipher_key, size_in):
|
|
"""
|
|
|
|
Decode a data structure from an arbitrary location in memory
|
|
using a cipher.
|
|
:param edd: The data descriptor to use when decoding.
|
|
:param data_in: The pointer to the data to decode into a struct.
|
|
:param cipher_key: The key to use as cipher.
|
|
:param size_in: The size of the data pointed to in bytes.
|
|
:return: NULL on failure, or a valid decoded struct pointer on success.
|
|
|
|
This function will decode a data structure that has been encoded using
|
|
eet_data_descriptor_encode(), and return a data structure with all its
|
|
elements filled out, if successful, or NULL on failure.
|
|
|
|
The data to be decoded is stored at the memory pointed to by @p data_in,
|
|
and is described by the descriptor pointed to by @p edd. The data size is
|
|
passed in as the value to @p size_in, ande must be greater than 0 to
|
|
succeed.
|
|
|
|
This function is useful for decoding data structures delivered to the
|
|
application by means other than an eet file, such as an IPC or socket
|
|
connection, raw files, shared memory etc.
|
|
|
|
Please see eet_data_read() for more information.
|
|
|
|
@see eet_data_descriptor_decode()
|
|
|
|
:since: 1.0.0
|
|
|
|
"""
|
|
EAPI void *
|
|
eet_data_descriptor_decode_cipher(Eet_Data_Descriptor *edd,
|
|
const void *data_in,
|
|
const char *cipher_key,
|
|
int size_in);
|
|
|
|
def encode_cipher(self, data_in, cipher_key):
|
|
"""
|
|
|
|
Encode a data struct to memory and return that encoded data
|
|
using a cipher.
|
|
:param edd: The data descriptor to use when encoding.
|
|
:param data_in: The pointer to the struct to encode into data.
|
|
:param cipher_key: The key to use as cipher.
|
|
:param size_ret: pointer to the an int to be filled with the decoded size.
|
|
:return: NULL on failure, or a valid encoded data chunk on success.
|
|
|
|
This function takes a data structutre in memory and encodes it into a
|
|
serialised chunk of data that can be decoded again by
|
|
eet_data_descriptor_decode(). This is useful for being able to transmit
|
|
data structures across sockets, pipes, IPC or shared file mechanisms,
|
|
without having to worry about memory space, machine type, endianess etc.
|
|
|
|
The parameter @p edd must point to a valid data descriptor, and
|
|
@p data_in must point to the right data structure to encode. If not, the
|
|
encoding may fail.
|
|
|
|
On success a non NULL valid pointer is returned and what @p size_ret
|
|
points to is set to the size of this decoded data, in bytes. When the
|
|
encoded data is no longer needed, call free() on it. On failure NULL is
|
|
returned and what @p size_ret points to is set to 0.
|
|
|
|
Please see eet_data_write() for more information.
|
|
|
|
@see eet_data_descriptor_encode()
|
|
|
|
:since: 1.0.0
|
|
|
|
"""
|
|
EAPI void *
|
|
eet_data_descriptor_encode_cipher(Eet_Data_Descriptor *edd,
|
|
const void *data_in,
|
|
const char *cipher_key,
|
|
int *size_ret);
|
|
|
|
|
|
def add_basic(self, struct_type, name, member, type):
|
|
"""
|
|
|
|
Add a basic data element to a data descriptor.
|
|
:param edd: The data descriptor to add the type to.
|
|
:param struct_type: The type of the struct.
|
|
:param name: The string name to use to encode/decode this member
|
|
(must be a constant global and never change).
|
|
:param member: The struct member itself to be encoded.
|
|
:param type: The type of the member to encode.
|
|
|
|
This macro is a convenience macro provided to add a member to
|
|
the data descriptor @p edd. The type of the structure is
|
|
provided as the @p struct_type parameter (for example: struct
|
|
my_struct). The @p name parameter defines a string that will be
|
|
used to uniquely name that member of the struct (it is suggested
|
|
to use the struct member itself). The @p member parameter is
|
|
the actual struct member itself (for example: values), and @p type is the
|
|
basic data type of the member which must be one of: EET_T_CHAR, EET_T_SHORT,
|
|
EET_T_INT, EET_T_LONG_LONG, EET_T_FLOAT, EET_T_DOUBLE, EET_T_UCHAR,
|
|
EET_T_USHORT, EET_T_UINT, EET_T_ULONG_LONG or EET_T_STRING.
|
|
|
|
:since: 1.0.0
|
|
|
|
"""
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(edd, struct_type, name, member, type)
|
|
|
|
def add_sub(self, struct_type, name, member, subtype):
|
|
"""
|
|
|
|
Add a sub-element type to a data descriptor
|
|
:param edd: The data descriptor to add the type to.
|
|
:param struct_type: The type of the struct.
|
|
:param name: The string name to use to encode/decode this member
|
|
(must be a constant global and never change).
|
|
:param member: The struct member itself to be encoded.
|
|
:param subtype: The type of sub-type struct to add.
|
|
|
|
This macro lets you easily add a sub-type (a struct that's pointed to
|
|
by this one). All the parameters are the same as for
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(), with the @p subtype being the exception.
|
|
This must be the data descriptor of the struct that is pointed to by
|
|
this element.
|
|
|
|
:since: 1.0.0
|
|
|
|
"""
|
|
EET_DATA_DESCRIPTOR_ADD_SUB(edd, struct_type, name, member, subtype)
|
|
|
|
def add_sub_nested(self, struct_type, name, member, subtype):
|
|
"""
|
|
|
|
Add a nested sub-element type to a data descriptor
|
|
:param edd: The data descriptor to add the type to.
|
|
:param struct_type: The type of the struct.
|
|
:param name: The string name to use to encode/decode this member
|
|
(must be a constant global and never change).
|
|
:param member: The struct member itself to be encoded.
|
|
:param subtype: The type of sub-type struct to add.
|
|
|
|
This macro lets you easily add a sub-type: a struct that is nested into
|
|
this one. If your data is pointed by this element instead of being nested,
|
|
you should use EET_DATA_DESCRIPTOR_ADD_SUB().
|
|
All the parameters are the same as for EET_DATA_DESCRIPTOR_ADD_SUB().
|
|
|
|
:since: 1.8.0
|
|
|
|
"""
|
|
EET_DATA_DESCRIPTOR_ADD_SUB_NESTED(edd, struct_type, name, member, subtype)
|
|
|
|
def add_list(self, struct_type, name, member, subtype):
|
|
"""
|
|
|
|
Add a linked list type to a data descriptor
|
|
:param edd: The data descriptor to add the type to.
|
|
:param struct_type: The type of the struct.
|
|
:param name: The string name to use to encode/decode this member
|
|
(must be a constant global and never change).
|
|
:param member: The struct member itself to be encoded.
|
|
:param subtype: The type of linked list member to add.
|
|
|
|
This macro lets you easily add a linked list of other data types. All the
|
|
parameters are the same as for EET_DATA_DESCRIPTOR_ADD_BASIC(), with the
|
|
@p subtype being the exception. This must be the data descriptor of the
|
|
element that is in each member of the linked list to be stored.
|
|
|
|
:since: 1.0.0
|
|
|
|
"""
|
|
EET_DATA_DESCRIPTOR_ADD_LIST(edd, struct_type, name, member, subtype)
|
|
|
|
def add_list_string(self, struct_type, name, member):
|
|
"""
|
|
|
|
Add a linked list of string to a data descriptor
|
|
:param edd: The data descriptor to add the type to.
|
|
:param struct_type: The type of the struct.
|
|
:param name: The string name to use to encode/decode this member
|
|
(must be a constant global and never change).
|
|
:param member: The struct member itself to be encoded.
|
|
|
|
This macro lets you easily add a linked list of char *. All the
|
|
parameters are the same as for EET_DATA_DESCRIPTOR_ADD_BASIC().
|
|
|
|
:since: 1.5.0
|
|
|
|
"""
|
|
EET_DATA_DESCRIPTOR_ADD_LIST_STRING(edd, struct_type, name, member)
|
|
|
|
def add_hash(self, struct_type, name, member, subtype):
|
|
"""
|
|
|
|
Add a hash type to a data descriptor
|
|
:param edd: The data descriptor to add the type to.
|
|
:param struct_type: The type of the struct.
|
|
:param name: The string name to use to encode/decode this member
|
|
(must be a constant global and never change).
|
|
:param member: The struct member itself to be encoded.
|
|
:param subtype: The type of hash member to add.
|
|
|
|
This macro lets you easily add a hash of other data types. All the
|
|
parameters are the same as for EET_DATA_DESCRIPTOR_ADD_BASIC(), with the
|
|
@p subtype being the exception. This must be the data descriptor of the
|
|
element that is in each member of the hash to be stored.
|
|
The hash keys must be strings.
|
|
|
|
:since: 1.0.0
|
|
|
|
"""
|
|
EET_DATA_DESCRIPTOR_ADD_HASH(edd, struct_type, name, member, subtype)
|
|
|
|
def add_hash_string(self, struct_type, name, member):
|
|
"""
|
|
|
|
Add a hash of string to a data descriptor
|
|
:param edd: The data descriptor to add the type to.
|
|
:param struct_type: The type of the struct.
|
|
:param name: The string name to use to encode/decode this member
|
|
(must be a constant global and never change).
|
|
:param member: The struct member itself to be encoded.
|
|
|
|
This macro lets you easily add a hash of string elements. All the
|
|
parameters are the same as for EET_DATA_DESCRIPTOR_ADD_HASH().
|
|
|
|
:since: 1.3.4
|
|
|
|
"""
|
|
EET_DATA_DESCRIPTOR_ADD_HASH_STRING(edd, struct_type, name, member)
|
|
|
|
def add_basic_array(self, struct_type, name, member, type):
|
|
"""
|
|
|
|
Add an array of basic data elements to a data descriptor.
|
|
:param edd: The data descriptor to add the type to.
|
|
:param struct_type: The type of the struct.
|
|
:param name: The string name to use to encode/decode this member
|
|
(must be a constant global and never change).
|
|
:param member: The struct member itself to be encoded.
|
|
:param type: The type of the member to encode.
|
|
|
|
This macro lets you easily add a fixed size array of basic data
|
|
types. All the parameters are the same as for
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC().
|
|
The array must be defined with a fixed size in the declaration of the
|
|
struct containing it.
|
|
|
|
:since: 1.5.0
|
|
|
|
"""
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC_ARRAY(edd, struct_type, name, member, type)
|
|
|
|
def add_basic_var_array(self, struct_type, name, member, type):
|
|
"""
|
|
|
|
Add a variable array of basic data elements to a data descriptor.
|
|
:param edd: The data descriptor to add the type to.
|
|
:param struct_type: The type of the struct.
|
|
:param name: The string name to use to encode/decode this member
|
|
(must be a constant global and never change).
|
|
:param member: The struct member itself to be encoded.
|
|
:param type: The type of the member to encode.
|
|
|
|
This macro lets you easily add a variable size array of basic data
|
|
types. All the parameters are the same as for
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(). This assumes you have
|
|
a struct member (of type EET_T_INT) called member_count (note the
|
|
_count appended to the member) that holds the number of items in
|
|
the array. This array will be allocated separately to the struct it
|
|
is in.
|
|
|
|
:since: 1.6.0
|
|
|
|
"""
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC_VAR_ARRAY(edd, struct_type, name, member, type)
|
|
|
|
def add_array(self, struct_type, name, member, subtype):
|
|
"""
|
|
|
|
Add a fixed size array type to a data descriptor
|
|
:param edd: The data descriptor to add the type to.
|
|
:param struct_type: The type of the struct.
|
|
:param name: The string name to use to encode/decode this member
|
|
(must be a constant global and never change).
|
|
:param member: The struct member itself to be encoded.
|
|
:param subtype: The type of hash member to add.
|
|
|
|
This macro lets you easily add a fixed size array of other data
|
|
types. All the parameters are the same as for
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(), with the @p subtype being the
|
|
exception. This must be the data descriptor of the element that
|
|
is in each member of the array to be stored.
|
|
The array must be defined with a fixed size in the declaration of the
|
|
struct containing it.
|
|
|
|
:since: 1.0.2
|
|
|
|
"""
|
|
EET_DATA_DESCRIPTOR_ADD_ARRAY(edd, struct_type, name, member, subtype)
|
|
|
|
def add_var_array(self, struct_type, name, member, subtype):
|
|
"""
|
|
|
|
Add a variable size array type to a data descriptor
|
|
:param edd: The data descriptor to add the type to.
|
|
:param struct_type: The type of the struct.
|
|
:param name: The string name to use to encode/decode this member
|
|
(must be a constant global and never change).
|
|
:param member: The struct member itself to be encoded.
|
|
:param subtype: The type of hash member to add.
|
|
|
|
This macro lets you easily add a variable size array of other data
|
|
types. All the parameters are the same as for
|
|
EET_DATA_DESCRIPTOR_ADD_BASIC(), with the @p subtype being the
|
|
exception. This must be the data descriptor of the element that
|
|
is in each member of the array to be stored. This assumes you have
|
|
a struct member (of type EET_T_INT) called member_count (note the
|
|
_count appended to the member) that holds the number of items in
|
|
the array. This array will be allocated separately to the struct it
|
|
is in.
|
|
|
|
:since: 1.0.2
|
|
|
|
"""
|
|
EET_DATA_DESCRIPTOR_ADD_VAR_ARRAY(edd, struct_type, name, member, subtype)
|
|
|
|
def add_var_array_string(self, struct_type, name, member):
|
|
"""
|
|
|
|
Add a variable size array type to a data descriptor
|
|
:param edd: The data descriptor to add the type to.
|
|
:param struct_type: The type of the struct.
|
|
:param name: The string name to use to encode/decode this member
|
|
(must be a constant global and never change).
|
|
:param member: The struct member itself to be encoded.
|
|
|
|
This macro lets you easily add a variable size array of strings. All
|
|
the parameters are the same as for EET_DATA_DESCRIPTOR_ADD_BASIC().
|
|
|
|
:since: 1.4.0
|
|
|
|
"""
|
|
EET_DATA_DESCRIPTOR_ADD_VAR_ARRAY_STRING(edd, struct_type, name, member)
|
|
|
|
def add_union(self, struct_type, name, member, type_member, unified_type):
|
|
"""
|
|
|
|
Add an union type to a data descriptor
|
|
:param edd: The data descriptor to add the type to.
|
|
:param struct_type: The type of the struct.
|
|
:param name: The string name to use to encode/decode this member
|
|
(must be a constant global and never change).
|
|
:param member: The struct member itself to be encoded.
|
|
:param type_member: The member that give hints on what is in the union.
|
|
:param unified_type: Describe all possible type the union could handle.
|
|
|
|
This macro lets you easily add an union with a member that specify what is inside.
|
|
The @p unified_type is an Eet_Data_Descriptor, but only the entry that match the name
|
|
returned by type_get will be used for each serialized data. The type_get and type_set
|
|
callback of unified_type should be defined.
|
|
|
|
:since: 1.2.4
|
|
:see: Eet_Data_Descriptor_Class
|
|
|
|
"""
|
|
EET_DATA_DESCRIPTOR_ADD_UNION(edd, struct_type, name, member, type_member, unified_type)
|
|
|
|
def add_variant(self, struct_type, name, member, type_member, unified_type):
|
|
"""
|
|
|
|
Add a automatically selectable type to a data descriptor
|
|
:param edd: The data descriptor to add the type to.
|
|
:param struct_type: The type of the struct.
|
|
:param name: The string name to use to encode/decode this member
|
|
(must be a constant global and never change).
|
|
:param member: The struct member itself to be encoded.
|
|
:param type_member: The member that give hints on what is in the union.
|
|
:param unified_type: Describe all possible type the union could handle.
|
|
|
|
This macro lets you easily define what the content of @p member points to depending of
|
|
the content of @p type_member. The type_get and type_set callback of unified_type should
|
|
be defined. If the the type is not know at the time of restoring it, eet will still call
|
|
type_set of @p unified_type but the pointer will be set to a serialized binary representation
|
|
of what eet know. This make it possible, to save this pointer again by just returning the string
|
|
given previously and telling it by setting unknow to EINA_TRUE.
|
|
|
|
:since: 1.2.4
|
|
:see: Eet_Data_Descriptor_Class
|
|
|
|
"""
|
|
EET_DATA_DESCRIPTOR_ADD_VARIANT(edd, struct_type, name, member, type_member, unified_type)
|
|
|
|
def add_mapping(self, name, subtype):
|
|
"""
|
|
|
|
Add a mapping to a data descriptor that will be used by union, variant or inherited type
|
|
:param unified_type: The data descriptor to add the mapping to.
|
|
:param name: The string name to get/set type.
|
|
:param subtype: The matching data descriptor.
|
|
|
|
:since: 1.2.4
|
|
:see: Eet_Data_Descriptor_Class
|
|
|
|
"""
|
|
EET_DATA_DESCRIPTOR_ADD_MAPPING(unified_type, name, subtype)
|
|
|
|
def add_mapping_basic(self, name, basic_type):
|
|
"""
|
|
|
|
Add a mapping of a basic type to a data descriptor that will be used by a union type.
|
|
:param unified_type: The data descriptor to add the mapping to.
|
|
:param name: The string name to get/set type.
|
|
:param basic_type: The matching basic type.
|
|
|
|
:since: 1.8
|
|
:see: Eet_Data_Descriptor_Class
|
|
|
|
"""
|
|
EET_DATA_DESCRIPTOR_ADD_MAPPING_BASIC(unified_type, name, basic_type)
|