/**
-@brief Eet Data Handling Library Public API Calls
+ @brief Eet Data Handling Library Public API Calls
-These routines are used for Eet Library interaction
+ These routines are used for Eet Library interaction
-@mainpage Eet Library Documentation
+ @mainpage Eet Library Documentation
-@version 1.5.0
-@date 2000-2011
+ @version 1.6.0
+ @date 2000-2012
-Please see the @ref authors page for contact details.
+ Please see the @ref authors page for contact details.
-@section toc Table of Contents
+ @section toc Table of Contents
-@li @ref intro
-@li @ref example
-@li @ref compiling
-@li @ref install
-@li @ref next_steps
-@li @ref intro_example
+ @li @ref intro
+ @li @ref example
+ @li @ref compiling
+ @li @ref install
+ @li @ref next_steps
+ @li @ref intro_example
-@section intro What is Eet?
+ @section intro What is Eet?
-It is a tiny library designed to write an arbitrary set of chunks of data
-to a file and optionally compress each chunk (very much like a zip file)
-and allow fast random-access reading of the file later on. It does not
-do zip as a zip itself has more complexity than is needed, and it was much
-simpler to implement this once here.
+ It is a tiny library designed to write an arbitrary set of chunks of data
+ to a file and optionally compress each chunk (very much like a zip file)
+ and allow fast random-access reading of the file later on. It does not
+ do zip as a zip itself has more complexity than is needed, and it was much
+ simpler to implement this once here.
-Eet is extremely fast, small and simple. Eet files can be very small and
-highly compressed, making them very optimal for just sending across the
-internet without having to archive, compress or decompress and install them.
-They allow for lightning-fast random-acess reads once created, making them
-perfect for storing data that is written once (or rarely) and read many
-times, but the program does not want to have to read it all in at once.
+ Eet is extremely fast, small and simple. Eet files can be very small and
+ highly compressed, making them very optimal for just sending across the
+ internet without having to archive, compress or decompress and install them.
+ They allow for lightning-fast random-access reads once created, making them
+ perfect for storing data that is written once (or rarely) and read many
+ times, but the program does not want to have to read it all in at once.
-It also can encode and decode data structures in memory, as well as image
-data for saving to Eet files or sending across the network to other
-machines, or just writing to arbitrary files on the system. All data is
-encoded in a platform independent way and can be written and read by any
-architecture.
+ It also can encode and decode data structures in memory, as well as image
+ data for saving to Eet files or sending across the network to other
+ machines, or just writing to arbitrary files on the system. All data is
+ encoded in a platform independent way and can be written and read by any
+ architecture.
-@section example A simple example on using Eet
+ @section example A simple example on using Eet
-Here is a simple example on how to use Eet to save a series of strings to a
-file and load them again. The advantage of using Eet over just fprintf() and
-fscanf() is that not only can these entries be strings, they need no special
-parsing to handle delimiter characters or escaping, they can be binary data,
-image data, data structures containing integers, strings, other data
-structures, linked lists and much more, without the programmer having to
-worry about parsing, and best of all, Eet is very fast.
+ Here is a simple example on how to use Eet to save a series of strings to a
+ file and load them again. The advantage of using Eet over just
+ fprintf() and
+ fscanf() is that not only can these entries be strings, they need no special
+ parsing to handle delimiter characters or escaping, they can be binary data,
+ image data, data structures containing integers, strings, other data
+ structures, linked lists and much more, without the programmer having to
+ worry about parsing, and best of all, Eet is very fast.
-This is just a very simple example that doesn't show all of the capabilities
-of Eet, but it serves to illustrate its simplicity.
+ This is just a very simple example that doesn't show all of the capabilities
+ of Eet, but it serves to illustrate its simplicity.
-@include eet-basic.c
+ @include eet-basic.c
-@section compiling How to compile using Eet ?
+ @section compiling How to compile using Eet ?
-Eet is a library your application links to. The procedure for this is very
-simple. You simply have to compile your application with the appropriate
-compiler flags that the @p pkg-config script outputs. For example:
+ Eet is a library your application links to. The procedure for this is very
+ simple. You simply have to compile your application with the appropriate
+ compiler flags that the @p pkg-config script outputs. For example:
-Compiling C or C++ files into object files:
+ Compiling C or C++ files into object files:
-@verbatim
-gcc -c -o main.o main.c `pkg-config --cflags eet`
-@endverbatim
+ @verbatim
+ gcc -c -o main.o main.c `pkg-config --cflags eet`
+ @endverbatim
-Linking object files into a binary executable:
+ Linking object files into a binary executable:
-@verbatim
-gcc -o my_application main.o `pkg-config --libs eet`
-@endverbatim
+ @verbatim
+ gcc -o my_application main.o `pkg-config --libs eet`
+ @endverbatim
-You simply have to make sure that pkg-config is in your shell's PATH (see
-the manual page for your appropriate shell) and eet.pc in /usr/lib/pkgconfig
-or its path is in the PKG_CONFIG_PATH environment variable. It's that simple
-to link and use Eet once you have written your code to use it.
+ You simply have to make sure that pkg-config is in your shell's PATH (see
+ the manual page for your appropriate shell) and eet.pc in /usr/lib/pkgconfig
+ or its path is in the PKG_CONFIG_PATH environment variable. It's that simple
+ to link and use Eet once you have written your code to use it.
-Since the program is linked to Eet, it is now able to use any advertised
-API calls to serialize your data.
+ Since the program is linked to Eet, it is now able to use any advertised
+ API calls to serialize your data.
-You should make sure you add any extra compile and link flags to your
-compile commands that your application may need as well. The above example
-is only guaranteed to make Eet add it's own requirements.
+ You should make sure you add any extra compile and link flags to your
+ compile commands that your application may need as well. The above example
+ is only guaranteed to make Eet add it's own requirements.
-@section install How is it installed?
+ @section install How is it installed?
-Simple:
+ Simple:
-@verbatim
-./configure
-make
-su -
-...
-make install
-@endverbatim
+ @verbatim
+ ./configure
+ make
+ su -
+ ...
+ make install
+ @endverbatim
-@section next_steps Next Steps
+ @section next_steps Next Steps
-After you understood what Eet is and installed it in your system you
-should proceed understanding the programming interface. We'd recommend
-you to take a while to learn Eina
-(http://docs.enlightenment.org/auto/eina/) as it is very convenient
-and optimized, and Eet provides integration with it.
+ After you understood what Eet is and installed it in your system you
+ should proceed understanding the programming interface. We'd recommend
+ you to take a while to learn Eina
+ (http://docs.enlightenment.org/auto/eina/) as it is very convenient
+ and optimized, and Eet provides integration with it.
-Recommended reading:
+ Recommended reading:
-@li @ref Eet_File_Group to know the basics to open and save files.
-@li @ref Eet_Data_Group to know the convenient way to serialize and
+ @li @ref Eet_File_Group to know the basics to open and save files.
+ @li @ref Eet_Data_Group to know the convenient way to serialize and
parse your data structures automatically. Just create your
descriptors and let Eet do the work for you.
-@section intro_example Introductory Examples
+ @section intro_example Introductory Examples
-@ref Examples
+ @ref Examples
-@todo Document data format for images and data structures.
+ @todo Document data format for images and data structures.
-*/
+ */
/**
-@page authors Authors
-@author Carsten Haitzler <raster@@rasterman.com>
-@author David Goodlad <dgoodlad@@gmail.com>
-@author Cedric Bail <cedric.bail@@free.fr>
-@author Arnaud de Turckheim <quarium@@gmail.com>
-@author Luis Felipe Strano Moraes <lfelipe@@profusion.mobi>
-@author Chidambar Zinnoury <illogict@@online.fr>
-@author Vincent Torri <vtorri@@univ-evry.fr>
-@author Gustavo Sverzut Barbieri <barbieri@@profusion.mobi>
-@author Raphael Kubo da Costa <kubo@@profusion.mobi>
-@author Mathieu Taillefumier <mathieu.taillefumier@@free.fr>
-@author Albin "Lutin" Tonnerre <albin.tonnerre@@gmail.com>
-@author Adam Simpkins <adam@@adamsimpkins.net>
-@author Mike Blumenkrantz <mike@zentific.com>
+ @page authors Authors
+ @author Carsten Haitzler <raster@@rasterman.com>
+ @author David Goodlad <dgoodlad@@gmail.com>
+ @author Cedric Bail <cedric.bail@@free.fr>
+ @author Arnaud de Turckheim <quarium@@gmail.com>
+ @author Luis Felipe Strano Moraes <lfelipe@@profusion.mobi>
+ @author Chidambar Zinnoury <illogict@@online.fr>
+ @author Vincent Torri <vtorri@@univ-evry.fr>
+ @author Gustavo Sverzut Barbieri <barbieri@@profusion.mobi>
+ @author Raphael Kubo da Costa <kubo@@profusion.mobi>
+ @author Mathieu Taillefumier <mathieu.taillefumier@@free.fr>
+
@author Albin "Lutin" Tonnerre <albin.tonnerre@@gmail.com>
+
@author Adam Simpkins <adam@@adamsimpkins.net>
+ @author Mike Blumenkrantz <michael.blumenkrantz@gmail.com>
-Please contact <enlightenment-devel@lists.sourceforge.net> to get in
-contact with the developers and maintainers.
-*/
+ Please contact <enlightenment-devel@lists.sourceforge.net> to get in
+ contact with the developers and maintainers.
+ */
#ifndef _EET_H
#define _EET_H
*/
#define EET_VERSION_MAJOR 1
-#define EET_VERSION_MINOR 4
+#define EET_VERSION_MINOR 6
/**
* @typedef Eet_Version
*
* #endif
* @endcode
*
- * Note the #if check can be dropped if your program refuses to compile or
+ * Note the \#if check can be dropped if your program refuses to compile or
* work with an Eet version less than 1.3.0.
*/
typedef struct _Eet_Version
int major; /** < major (binary or source incompatible changes) */
int minor; /** < minor (new features, bugfixes, major improvements version) */
int micro; /** < micro (bugfix, internal improvements, no new features version) */
- int revision; /** < svn revision (0 if a proper rlease or the svn revsion number Eet is built from) */
+ int revision; /** < svn revision (0 if a proper release or the svn revision number Eet is built from) */
} Eet_Version;
EAPI extern Eet_Version *eet_version;
/**
* @}
*/
+
+/**
+ * @defgroup Eet_Compression Eet Compression Levels
+ * Compression modes/levels supported by Eet.
+ *
+ * @{
+ */
+
+/**
+ * @enum _Eet_Compression
+ * All the compression modes known by Eet.
+ */
+
+typedef enum _Eet_Compression
+{
+ EET_COMPRESSION_NONE = 0, /**< No compression at all @since 1.7 */
+ EET_COMPRESSION_DEFAULT = 1, /**< Default compression (Zlib) @since 1.7 */
+ EET_COMPRESSION_LOW = 2, /**< Fast but minimal compression (Zlib) @since 1.7 */
+ EET_COMPRESSION_MED = 6, /**< Medium compression level (Zlib) @since 1.7 */
+ EET_COMPRESSION_HI = 9, /**< Slow but high compression level (Zlib) @since 1.7 */
+ EET_COMPRESSION_VERYFAST = 10, /**< Very fast, but lower compression ratio (LZ4HC) @since 1.7 */
+ EET_COMPRESSION_SUPERFAST = 11, /**< Very fast, but lower compression ratio (faster to compress than EET_COMPRESSION_VERYFAST) (LZ4) @since 1.7 */
+
+ EET_COMPRESSION_LOW2 = 3, /**< Space filler for compatibility. Don't use it @since 1.7 */
+ EET_COMPRESSION_MED1 = 4, /**< Space filler for compatibility. Don't use it @since 1.7 */
+ EET_COMPRESSION_MED2 = 5, /**< Space filler for compatibility. Don't use it @since 1.7 */
+ EET_COMPRESSION_HI1 = 7, /**< Space filler for compatibility. Don't use it @since 1.7 */
+ EET_COMPRESSION_HI2 = 8 /**< Space filler for compatibility. Don't use it @since 1.7 */
+} Eet_Compression; /**< Eet compression modes @since 1.7 */
+
+/**
+ * @}
+ */
/**
* Initialize the EET library.
*
* The first time this function is called, it will perform all the internal
- * initialization required for the library to function properly and incrememnt
- * the initializiation counter. Any subsequent call only increment this counter
+ * initialization required for the library to function properly and increment
+ * the initialization counter. Any subsequent call only increment this counter
* and return its new value, so it's safe to call this function more than once.
*
* @return The new init count. Will be 0 if initialization failed.
*
* Next, we copy into our buffer our set of strings, including their null
* terminators and write them into the file. No error checking for the sake
- * of brevitiy. And a call to eet_sync() to make sure all out data is
+ * of brevity. And a call to eet_sync() to make sure all out data is
* properly written down to disk, even though we haven't yet closed the file.
* @until eet_sync
*
*
* This handle will be returned by the functions eet_open() and
* eet_memopen_read() and is used by every other function that affects the
- * file in any way. When you are done with it, call eet_close() to clsoe it
+ * file in any way. When you are done with it, call eet_close() to close it
* and, if the file was open for writing, write down to disk any changes made
* to it.
*
* @see eet_memopen_read()
* @see eet_close()
*/
-typedef struct _Eet_File Eet_File;
+typedef struct _Eet_File Eet_File;
/**
* @typedef Eet_Dictionary
* Opaque handle that defines a file-backed (mmaped) dictionary of strings.
*/
-typedef struct _Eet_Dictionary Eet_Dictionary;
+typedef struct _Eet_Dictionary Eet_Dictionary;
/**
* @}
* @since 1.0.0
*/
EAPI Eet_File *
-eet_open(const char *file,
+eet_open(const char *file,
Eet_File_Mode mode);
/**
* so you must keep it around as long as the eet file is open. There is
* currently no cache for this kind of Eet_File, so it's reopened every time
* you use eet_memopen_read.
+ * @param data Address of file in memory.
+ * @param size Size of memory to be read.
+ * @return A handle to the file.
+ *
* Files opened this way will always be in read-only mode.
*
* @since 1.1.0
*/
EAPI Eet_File *
eet_memopen_read(const void *data,
- size_t size);
+ size_t size);
/**
* Get the mode an Eet_File was opened with.
eet_mode_get(Eet_File *ef);
/**
- * Close an eet file handle and flush and writes pending.
+ * Close an eet file handle and flush pending writes.
* @param ef A valid eet file handle.
+ * @return An eet error identifier.
*
* This function will flush any pending writes to disk if the eet file
* was opened for write, and free all data associated with the file handle
- * and file, and close the file.
+ * and file, and close the file. If it was opened for read (or read/write),
+ * the file handle may still be held open internally for caching purposes.
+ * To flush speculatively held eet file handles use eet_clearcache().
*
* If the eet file handle is not valid nothing will be done.
*
* @since 1.0.0
* @ingroup Eet_File_Group
+ *
+ * @see eet_clearcache()
*/
EAPI Eet_Error
eet_close(Eet_File *ef);
/**
* Sync content of an eet file handle, flushing pending writes.
* @param ef A valid eet file handle.
+ * @return An eet error identifier.
*
* This function will flush any pending writes to disk. The eet file must
* be opened for write.
*
* @see eet_dictionary_string_check() to know if given string came
* from the dictionary or it was dynamically allocated using
- * the #Eet_Data_Descriptor_Class instructrions.
+ * the #Eet_Data_Descriptor_Class instructions.
*
* @since 1.0.0
* @ingroup Eet_File_Group
*/
EAPI int
eet_dictionary_string_check(Eet_Dictionary *ed,
- const char *string);
+ const char *string);
+
+/**
+ * Return the number of strings inside a dictionary
+ * @param ed A valid dictionary handle
+ * @return the number of strings inside a dictionary
+ *
+ * @since 1.6.0
+ * @ingroup Eet_File_Group
+ */
+EAPI int
+eet_dictionary_count(const Eet_Dictionary *ed);
/**
* Read a specified entry from an eet file and return data
* @ingroup Eet_File_Group
*/
EAPI void *
-eet_read(Eet_File *ef,
+eet_read(Eet_File *ef,
const char *name,
- int *size_ret);
+ int *size_ret);
/**
* Read a specified entry from an eet file and return data
* This function finds an entry in the eet file that is stored under the
* name specified, and returns that data if not compressed and successful.
* NULL is returned if the lookup fails or if memory errors are
- * encountered or if the data is comrpessed. The calling program must never
+ * encountered or if the data is compressed. The calling program must never
* call free() on the returned data. The number of bytes in the returned
* data chunk are placed in size_ret.
*
* @ingroup Eet_File_Group
*/
EAPI const void *
-eet_read_direct(Eet_File *ef,
+eet_read_direct(Eet_File *ef,
const char *name,
- int *size_ret);
+ int *size_ret);
/**
* Write a specified entry to an eet file handle
* @ingroup Eet_File_Group
*/
EAPI int
-eet_write(Eet_File *ef,
+eet_write(Eet_File *ef,
const char *name,
const void *data,
- int size,
- int compress);
+ int size,
+ int compress);
/**
* Delete a specified entry from an Eet file being written or re-written
* @ingroup Eet_File_Group
*/
EAPI int
-eet_delete(Eet_File *ef,
+eet_delete(Eet_File *ef,
const char *name);
/**
* Alias a specific section to another one. Destination may exist or not,
- * no check are done.
+ * no checks are done.
* @param ef A valid eet file handle opened for writing.
* @param name Name of the new entry. eg: "/base/file_i_want".
* @param destination Actual source of the aliased entry eg: "/base/the_real_stuff_i_want".
* @ingroup Eet_File_Group
*/
EAPI Eina_Bool
-eet_alias(Eet_File *ef,
+eet_alias(Eet_File *ef,
const char *name,
const char *destination,
- int compress);
+ int compress);
+
+/**
+ * Retrieve the filename of an Eet_File
+ * @param ef A valid eet file handle opened for writing.
+ * @return The stringshared file string opened with eet_open(), or NULL on error
+ *
+ * @note This function will return NULL for files opened with eet_memopen_read()
+ *
+ * @since 1.6
+ * @ingroup Eet_File_Group
+ */
+EAPI const char *
+eet_file_get(Eet_File *ef);
/**
* Retrieve the destination name of an alias
* @ingroup Eet_File_Group
*/
EAPI char **
-eet_list(Eet_File *ef,
+eet_list(Eet_File *ef,
const char *glob,
- int *count_ret);
+ int *count_ret);
/**
* Return the number of entries in the specified eet file.
* @ingroup Eet_File_Cipher_Group
*/
EAPI void *
-eet_read_cipher(Eet_File *ef,
+eet_read_cipher(Eet_File *ef,
const char *name,
- int *size_ret,
+ int *size_ret,
const char *cipher_key);
/**
* @ingroup Eet_File_Cipher_Group
*/
EAPI int
-eet_write_cipher(Eet_File *ef,
+eet_write_cipher(Eet_File *ef,
const char *name,
const void *data,
- int size,
- int compress,
+ int size,
+ int compress,
const char *cipher_key);
/**
* will be 1 or 0, denoting if the alpha channel of the image is used or not.
* If the image was losslessly compressed, the @p compress parameter will hold
* the compression amount used, ranging from 0 to 9 and @p lossy will be 0.
- * In the case of lossy compression, @p lossy will be 1, and the compreesion
+ * In the case of lossy compression, @p lossy will be 1, and the compression
* quality will be placed under @p quality, with a value ranging from 0 to 100.
*
* @see eet_data_image_header_decode()
* @ingroup Eet_File_Image_Group
*/
EAPI int
-eet_data_image_header_read(Eet_File *ef,
- const char *name,
+eet_data_image_header_read(Eet_File *ef,
+ const char *name,
unsigned int *w,
unsigned int *h,
- int *alpha,
- int *compress,
- int *quality,
- int *lossy);
+ int *alpha,
+ int *compress,
+ int *quality,
+ int *lossy);
/**
* Read image data from the named key in the eet file.
* @ingroup Eet_File_Image_Group
*/
EAPI void *
-eet_data_image_read(Eet_File *ef,
- const char *name,
+eet_data_image_read(Eet_File *ef,
+ const char *name,
unsigned int *w,
unsigned int *h,
- int *alpha,
- int *compress,
- int *quality,
- int *lossy);
+ int *alpha,
+ int *compress,
+ int *quality,
+ int *lossy);
/**
* Read image data from the named key in the eet file and store it in the given buffer.
* @ingroup Eet_File_Image_Group
*/
EAPI int
-eet_data_image_read_to_surface(Eet_File *ef,
- const char *name,
- unsigned int src_x,
- unsigned int src_y,
+eet_data_image_read_to_surface(Eet_File *ef,
+ const char *name,
+ unsigned int src_x,
+ unsigned int src_y,
unsigned int *d,
- unsigned int w,
- unsigned int h,
- unsigned int row_stride,
- int *alpha,
- int *compress,
- int *quality,
- int *lossy);
+ unsigned int w,
+ unsigned int h,
+ unsigned int row_stride,
+ int *alpha,
+ int *compress,
+ int *quality,
+ int *lossy);
/**
* Write image data to the named key in an eet file.
* @ingroup Eet_File_Image_Group
*/
EAPI int
-eet_data_image_write(Eet_File *ef,
- const char *name,
- const void *data,
+eet_data_image_write(Eet_File *ef,
+ const char *name,
+ const void *data,
unsigned int w,
unsigned int h,
- int alpha,
- int compress,
- int quality,
- int lossy);
+ int alpha,
+ int compress,
+ int quality,
+ int lossy);
/**
* Decode Image data header only to get information.
* @ingroup Eet_File_Image_Group
*/
EAPI int
-eet_data_image_header_decode(const void *data,
- int size,
+eet_data_image_header_decode(const void *data,
+ int size,
unsigned int *w,
unsigned int *h,
- int *alpha,
- int *compress,
- int *quality,
- int *lossy);
+ int *alpha,
+ int *compress,
+ int *quality,
+ int *lossy);
/**
* Decode Image data into pixel data.
* @ingroup Eet_File_Image_Group
*/
EAPI void *
-eet_data_image_decode(const void *data,
- int size,
+eet_data_image_decode(const void *data,
+ int size,
unsigned int *w,
unsigned int *h,
- int *alpha,
- int *compress,
- int *quality,
- int *lossy);
+ int *alpha,
+ int *compress,
+ int *quality,
+ int *lossy);
/**
* Decode Image data into pixel data and stores in the given buffer.
* @ingroup Eet_File_Image_Group
*/
EAPI int
-eet_data_image_decode_to_surface(const void *data,
- int size,
- unsigned int src_x,
- unsigned int src_y,
+eet_data_image_decode_to_surface(const void *data,
+ int size,
+ unsigned int src_x,
+ unsigned int src_y,
unsigned int *d,
- unsigned int w,
- unsigned int h,
- unsigned int row_stride,
- int *alpha,
- int *compress,
- int *quality,
- int *lossy);
+ unsigned int w,
+ unsigned int h,
+ unsigned int row_stride,
+ int *alpha,
+ int *compress,
+ int *quality,
+ int *lossy);
/**
* Encode image data for storage or transmission.
* @ingroup Eet_File_Image_Group
*/
EAPI void *
-eet_data_image_encode(const void *data,
- int *size_ret,
+eet_data_image_encode(const void *data,
+ int *size_ret,
unsigned int w,
unsigned int h,
- int alpha,
- int compress,
- int quality,
- int lossy);
+ int alpha,
+ int compress,
+ int quality,
+ int lossy);
/**
* @defgroup Eet_File_Image_Cipher_Group Image Store and Load using a Cipher
* @ingroup Eet_File_Image_Cipher_Group
*/
EAPI int
-eet_data_image_header_read_cipher(Eet_File *ef,
- const char *name,
- const char *cipher_key,
+eet_data_image_header_read_cipher(Eet_File *ef,
+ const char *name,
+ const char *cipher_key,
unsigned int *w,
unsigned int *h,
- int *alpha,
- int *compress,
- int *quality,
- int *lossy);
+ int *alpha,
+ int *compress,
+ int *quality,
+ int *lossy);
/**
* Read image data from the named key in the eet file using a cipher.
* @ingroup Eet_File_Image_Cipher_Group
*/
EAPI void *
-eet_data_image_read_cipher(Eet_File *ef,
- const char *name,
- const char *cipher_key,
+eet_data_image_read_cipher(Eet_File *ef,
+ const char *name,
+ const char *cipher_key,
unsigned int *w,
unsigned int *h,
- int *alpha,
- int *compress,
- int *quality,
- int *lossy);
+ int *alpha,
+ int *compress,
+ int *quality,
+ int *lossy);
/**
* Read image data from the named key in the eet file using a cipher.
* @ingroup Eet_File_Image_Cipher_Group
*/
EAPI int
-eet_data_image_read_to_surface_cipher(Eet_File *ef,
- const char *name,
- const char *cipher_key,
- unsigned int src_x,
- unsigned int src_y,
+eet_data_image_read_to_surface_cipher(Eet_File *ef,
+ const char *name,
+ const char *cipher_key,
+ unsigned int src_x,
+ unsigned int src_y,
unsigned int *d,
- unsigned int w,
- unsigned int h,
- unsigned int row_stride,
- int *alpha,
- int *compress,
- int *quality,
- int *lossy);
+ unsigned int w,
+ unsigned int h,
+ unsigned int row_stride,
+ int *alpha,
+ int *compress,
+ int *quality,
+ int *lossy);
/**
* Write image data to the named key in an eet file using a cipher.
* @ingroup Eet_File_Image_Cipher_Group
*/
EAPI int
-eet_data_image_write_cipher(Eet_File *ef,
- const char *name,
- const char *cipher_key,
- const void *data,
+eet_data_image_write_cipher(Eet_File *ef,
+ const char *name,
+ const char *cipher_key,
+ const void *data,
unsigned int w,
unsigned int h,
- int alpha,
- int compress,
- int quality,
- int lossy);
+ int alpha,
+ int compress,
+ int quality,
+ int lossy);
/**
* Decode Image data header only to get information using a cipher.
* @ingroup Eet_File_Image_Cipher_Group
*/
EAPI int
-eet_data_image_header_decode_cipher(const void *data,
- const char *cipher_key,
- int size,
+eet_data_image_header_decode_cipher(const void *data,
+ const char *cipher_key,
+ int size,
unsigned int *w,
unsigned int *h,
- int *alpha,
- int *compress,
- int *quality,
- int *lossy);
+ int *alpha,
+ int *compress,
+ int *quality,
+ int *lossy);
/**
* Decode Image data into pixel data using a cipher.
* @ingroup Eet_File_Image_Cipher_Group
*/
EAPI void *
-eet_data_image_decode_cipher(const void *data,
- const char *cipher_key,
- int size,
+eet_data_image_decode_cipher(const void *data,
+ const char *cipher_key,
+ int size,
unsigned int *w,
unsigned int *h,
- int *alpha,
- int *compress,
- int *quality,
- int *lossy);
+ int *alpha,
+ int *compress,
+ int *quality,
+ int *lossy);
/**
* Decode Image data into pixel data using a cipher.
* @ingroup Eet_File_Image_Cipher_Group
*/
EAPI int
-eet_data_image_decode_to_surface_cipher(const void *data,
- const char *cipher_key,
- int size,
- unsigned int src_x,
- unsigned int src_y,
+eet_data_image_decode_to_surface_cipher(const void *data,
+ const char *cipher_key,
+ int size,
+ unsigned int src_x,
+ unsigned int src_y,
unsigned int *d,
- unsigned int w,
- unsigned int h,
- unsigned int row_stride,
- int *alpha,
- int *compress,
- int *quality,
- int *lossy);
+ unsigned int w,
+ unsigned int h,
+ unsigned int row_stride,
+ int *alpha,
+ int *compress,
+ int *quality,
+ int *lossy);
/**
* Encode image data for storage or transmission using a cipher.
* @ingroup Eet_File_Image_Cipher_Group
*/
EAPI void *
-eet_data_image_encode_cipher(const void *data,
- const char *cipher_key,
- unsigned int w,
- unsigned int h,
- int alpha,
- int compress,
- int quality,
- int lossy,
- int *size_ret);
+eet_data_image_encode_cipher(const void *data,
+ const char *cipher_key,
+ unsigned int w,
+ unsigned int h,
+ int alpha,
+ int compress,
+ int quality,
+ int lossy,
+ int *size_ret);
/**
* @defgroup Eet_Cipher_Group Cipher, Identity and Protection Mechanisms
* Opaque handle that defines an identity (also known as key)
* in Eet's cipher system.
*/
-typedef struct _Eet_Key Eet_Key;
+typedef struct _Eet_Key Eet_Key;
/**
* @}
* @since 1.2.0
* @ingroup Eet_Cipher_Group
*/
-typedef int (*Eet_Key_Password_Callback) (char *buffer, int size, int rwflag, void *data);
+typedef int (*Eet_Key_Password_Callback)(char *buffer, int size, int rwflag, void *data);
/**
* Create an Eet_Key needed for signing an eet file.
* @ingroup Eet_Cipher_Group
*/
EAPI Eet_Key *
-eet_identity_open(const char *certificate_file,
- const char *private_key_file,
- Eet_Key_Password_Callback cb);
+eet_identity_open(const char *certificate_file,
+ const char *private_key_file,
+ Eet_Key_Password_Callback cb);
/**
- * Close and release all ressource used by an Eet_Key. An
+ * Close and release all resource used by an Eet_Key. An
* reference counter prevent it from being freed until all file
* using it are also closed.
*
*/
EAPI Eet_Error
eet_identity_set(Eet_File *ef,
- Eet_Key *key);
+ Eet_Key *key);
/**
* Display both private and public key of an Eet_Key.
*/
EAPI void
eet_identity_print(Eet_Key *key,
- FILE *out);
+ FILE *out);
/**
* Get the x509 der certificate associated with an Eet_File. Will return NULL
*/
EAPI const void *
eet_identity_x509(Eet_File *ef,
- int *der_length);
+ int *der_length);
/**
* Get the raw signature associated with an Eet_File. Will return NULL
*/
EAPI const void *
eet_identity_signature(Eet_File *ef,
- int *signature_length);
+ int *signature_length);
/**
* Get the SHA1 associated with a file. Could be the one used to
*/
EAPI const void *
eet_identity_sha1(Eet_File *ef,
- int *sha1_length);
+ int *sha1_length);
/**
* Display the x509 der certificate to out.
*/
EAPI void
eet_identity_certificate_print(const unsigned char *certificate,
- int der_length,
- FILE *out);
+ int der_length,
+ FILE *out);
/**
* @defgroup Eet_Data_Group Eet Data Serialization
* use it to load older configuration files and update them as needed.
* @until }
*
- * Finally, clsoe the file and return the newly loaded config data.
+ * Finally, close the file and return the newly loaded config data.
* @until }
*
* Saving data is just as easy. The full version of the following function
* We won't ignore the headers this time to show how easy it is to use Eina
* data types with Eet, but we'll still skip most of the code that is not
* pertinent to what we want to show now, but as usual, you can get it full
- * by follwing @ref eet-data-nested.c "this link".
+ * by following @ref eet-data-nested.c "this link".
*
* @dontinclude eet-data-nested.c
* @skipline Eina.h
* @see eet_data_descriptor_file_new()
* @see eet_data_descriptor_free()
*/
-typedef struct _Eet_Data_Descriptor Eet_Data_Descriptor;
+typedef struct _Eet_Data_Descriptor Eet_Data_Descriptor;
/**
* @def EET_DATA_DESCRIPTOR_CLASS_VERSION
* Instructs Eet about memory management for different needs under
* serialization and parse process.
*/
-typedef struct _Eet_Data_Descriptor_Class Eet_Data_Descriptor_Class;
-
-typedef int (*Eet_Descriptor_Hash_Foreach_Callback_Callback)(void *h, const char *k, void *dt, void *fdt);
-
-typedef void *(*Eet_Descriptor_Mem_Alloc_Callback)(size_t size);
-typedef void (*Eet_Descriptor_Mem_Free_Callback)(void *mem);
-typedef char *(*Eet_Descriptor_Str_Alloc_Callback)(const char *str);
-typedef void (*Eet_Descriptor_Str_Free_Callback)(const char *str);
-typedef void *(*Eet_Descriptor_List_Next_Callback)(void *l);
-typedef void *(*Eet_Descriptor_List_Append_Callback)(void *l, void *d);
-typedef void *(*Eet_Descriptor_List_Data_Callback)(void *l);
-typedef void *(*Eet_Descriptor_List_Free_Callback)(void *l);
-typedef void (*Eet_Descriptor_Hash_Foreach_Callback)(void *h, Eet_Descriptor_Hash_Foreach_Callback_Callback func, void *fdt);
-typedef void *(*Eet_Descriptor_Hash_Add_Callback)(void *h, const char *k, void *d);
-typedef void (*Eet_Descriptor_Hash_Free_Callback)(void *h);
-typedef char *(*Eet_Descriptor_Str_Direct_Alloc_Callback)(const char *str);
-typedef void (*Eet_Descriptor_Str_Direct_Free_Callback)(const char *str);
-typedef const char *(*Eet_Descriptor_Type_Get_Callback)(const void *data, Eina_Bool *unknow);
-typedef Eina_Bool (*Eet_Descriptor_Type_Set_Callback)(const char *type, void *data, Eina_Bool unknow);
-typedef void *(*Eet_Descriptor_Array_Alloc_Callback)(size_t size);
-typedef void (*Eet_Descriptor_Array_Free_Callback)(void *mem);
+typedef struct _Eet_Data_Descriptor_Class Eet_Data_Descriptor_Class;
+
+typedef int (*Eet_Descriptor_Hash_Foreach_Callback_Callback)(void *h, const char *k, void *dt, void *fdt);
+
+typedef void * (*Eet_Descriptor_Mem_Alloc_Callback)(size_t size);
+typedef void (*Eet_Descriptor_Mem_Free_Callback)(void *mem);
+typedef char * (*Eet_Descriptor_Str_Alloc_Callback)(const char *str);
+typedef void (*Eet_Descriptor_Str_Free_Callback)(const char *str);
+typedef void * (*Eet_Descriptor_List_Next_Callback)(void *l);
+typedef void * (*Eet_Descriptor_List_Append_Callback)(void *l, void *d);
+typedef void * (*Eet_Descriptor_List_Data_Callback)(void *l);
+typedef void * (*Eet_Descriptor_List_Free_Callback)(void *l);
+typedef void (*Eet_Descriptor_Hash_Foreach_Callback)(void *h, Eet_Descriptor_Hash_Foreach_Callback_Callback func, void *fdt);
+typedef void * (*Eet_Descriptor_Hash_Add_Callback)(void *h, const char *k, void *d);
+typedef void (*Eet_Descriptor_Hash_Free_Callback)(void *h);
+typedef char * (*Eet_Descriptor_Str_Direct_Alloc_Callback)(const char *str);
+typedef void (*Eet_Descriptor_Str_Direct_Free_Callback)(const char *str);
+typedef const char * (*Eet_Descriptor_Type_Get_Callback)(const void *data, Eina_Bool *unknow);
+typedef Eina_Bool (*Eet_Descriptor_Type_Set_Callback)(const char *type, void *data, Eina_Bool unknow);
+typedef void * (*Eet_Descriptor_Array_Alloc_Callback)(size_t size);
+typedef void (*Eet_Descriptor_Array_Free_Callback)(void *mem);
/**
* @struct _Eet_Data_Descriptor_Class
*
* Instructs Eet about memory management for different needs under
* serialization and parse process.
*
- * The list and hash methods match the Eina API, so for a more detalied
+ * The list and hash methods match the Eina API, so for a more detailed
* reference on them, look at the Eina_List and Eina_Hash documentation,
* respectively.
* For the most part these will be used with the standard Eina functions,
int version; /**< ABI version. Should always be set to #EET_DATA_DESCRIPTOR_CLASS_VERSION */
const char *name; /**< Name of the user data type to be serialized */
int size; /**< Size in bytes of the user data type to be serialized */
- struct {
- Eet_Descriptor_Mem_Alloc_Callback mem_alloc; /**< how to allocate memory (usually malloc()) */
- Eet_Descriptor_Mem_Free_Callback mem_free; /**< how to free memory (usually free()) */
- Eet_Descriptor_Str_Alloc_Callback str_alloc; /**< how to allocate a string */
- Eet_Descriptor_Str_Free_Callback str_free; /**< how to free a string */
- Eet_Descriptor_List_Next_Callback list_next; /**< how to iterate to the next element of a list. Receives and should return the list node. */
- Eet_Descriptor_List_Append_Callback list_append; /**< how to append data @p d to list which head node is @p l */
- Eet_Descriptor_List_Data_Callback list_data; /**< retrieves the data from node @p l */
- Eet_Descriptor_List_Free_Callback list_free; /**< free all the nodes from the list which head node is @p l */
- Eet_Descriptor_Hash_Foreach_Callback hash_foreach; /**< iterates over all elements in the hash @p h in no specific order */
- Eet_Descriptor_Hash_Add_Callback hash_add; /**< add a new data @p d with key @p k in hash @p h */
- Eet_Descriptor_Hash_Free_Callback hash_free; /**< free all entries from the hash @p h */
- Eet_Descriptor_Str_Direct_Alloc_Callback str_direct_alloc; /**< how to allocate a string directly from file backed/mmaped region pointed by @p str */
- Eet_Descriptor_Str_Direct_Free_Callback str_direct_free; /**< how to free a string returned by str_direct_alloc */
- Eet_Descriptor_Type_Get_Callback type_get; /**< get the type, as used in the union or variant mapping, that should be used to store the given data into the eet file. */
- Eet_Descriptor_Type_Set_Callback type_set; /**< called when loading a mapped type with the given @p type used to describe the type in the descriptor */
- Eet_Descriptor_Array_Alloc_Callback array_alloc; /**< how to allocate memory for array (usually malloc()) */
- Eet_Descriptor_Array_Free_Callback array_free; /**< how to free memory for array (usually free()) */
+ struct
+ {
+ Eet_Descriptor_Mem_Alloc_Callback mem_alloc; /**< how to allocate memory (usually malloc()) */
+ Eet_Descriptor_Mem_Free_Callback mem_free; /**< how to free memory (usually free()) */
+ Eet_Descriptor_Str_Alloc_Callback str_alloc; /**< how to allocate a string */
+ Eet_Descriptor_Str_Free_Callback str_free; /**< how to free a string */
+ Eet_Descriptor_List_Next_Callback list_next; /**< how to iterate to the next element of a list. Receives and should return the list node. */
+ Eet_Descriptor_List_Append_Callback list_append; /**< how to append data @p d to list which head node is @p l */
+ Eet_Descriptor_List_Data_Callback list_data; /**< retrieves the data from node @p l */
+ Eet_Descriptor_List_Free_Callback list_free; /**< free all the nodes from the list which head node is @p l */
+ Eet_Descriptor_Hash_Foreach_Callback hash_foreach; /**< iterates over all elements in the hash @p h in no specific order */
+ Eet_Descriptor_Hash_Add_Callback hash_add; /**< add a new data @p d with key @p k in hash @p h */
+ Eet_Descriptor_Hash_Free_Callback hash_free; /**< free all entries from the hash @p h */
+ Eet_Descriptor_Str_Direct_Alloc_Callback str_direct_alloc; /**< how to allocate a string directly from file backed/mmaped region pointed by @p str */
+ Eet_Descriptor_Str_Direct_Free_Callback str_direct_free; /**< how to free a string returned by str_direct_alloc */
+ Eet_Descriptor_Type_Get_Callback type_get; /**< get the type, as used in the union or variant mapping, that should be used to store the given data into the eet file. */
+ Eet_Descriptor_Type_Set_Callback type_set; /**< called when loading a mapped type with the given @p type used to describe the type in the descriptor */
+ Eet_Descriptor_Array_Alloc_Callback array_alloc; /**< how to allocate memory for array (usually malloc()) */
+ Eet_Descriptor_Array_Free_Callback array_free; /**< how to free memory for array (usually free()) */
} func;
};
* @}
*/
-
/**
* Create a new empty data structure descriptor.
* @param name The string name of this data structure (most be a
* @param func_hash_free The function to free an entire hash table.
* @return A new empty data descriptor.
*
- * This function creates a new data descriptore and returns a handle to the
+ * 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.
*
* move happens - but be warned
*/
EINA_DEPRECATED EAPI Eet_Data_Descriptor *
-eet_data_descriptor2_new(const Eet_Data_Descriptor_Class *eddc);
+ eet_data_descriptor2_new(const Eet_Data_Descriptor_Class *eddc);
EINA_DEPRECATED EAPI Eet_Data_Descriptor *
-eet_data_descriptor3_new(const Eet_Data_Descriptor_Class *eddc);
+ eet_data_descriptor3_new(const Eet_Data_Descriptor_Class *eddc);
/**
* 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
* adding to the description.
*
* Once you have described all the members of a struct you want loaded or
- * savedi, eet can load and save those members for you, encode them into
+ * 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.
+ * 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,
* 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
* adding to the description.
*
* Once you have described all the members of a struct you want loaded or
- * savedi, eet can load and save those members for you, encode them into
+ * 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.
*
*/
EAPI Eina_Bool
eet_eina_stream_data_descriptor_class_set(Eet_Data_Descriptor_Class *eddc,
- unsigned int eddc_size,
- const char *name,
- int size);
+ unsigned int eddc_size,
+ const char *name,
+ int size);
/**
* This macro is an helper that set all the parameter of an
* @since 1.2.3
* @ingroup Eet_Data_Group
*/
-#define EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(clas, type)\
- (eet_eina_stream_data_descriptor_class_set(clas, sizeof (*(clas)), # type, sizeof(type)))
+#define EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(clas, type) \
+ (eet_eina_stream_data_descriptor_class_set(clas, sizeof (*(clas)), # type, sizeof(type)))
/**
* This function is an helper that set all the parameter of an
*/
EAPI Eina_Bool
eet_eina_file_data_descriptor_class_set(Eet_Data_Descriptor_Class *eddc,
- unsigned int eddc_size,
- const char *name,
- int size);
+ unsigned int eddc_size,
+ const char *name,
+ int size);
/**
* This macro is an helper that set all the parameter of an
* @since 1.2.3
* @ingroup Eet_Data_Group
*/
-#define EET_EINA_FILE_DATA_DESCRIPTOR_CLASS_SET(clas, type)\
+#define EET_EINA_FILE_DATA_DESCRIPTOR_CLASS_SET(clas, type) \
(eet_eina_file_data_descriptor_class_set(clas, sizeof (*(clas)), # type, sizeof(type)))
/**
* #EET_T_INT. If #EET_T_UNKNOW, then it is considered to be a
* group, list or hash.
* @param group_type If element type is #EET_T_UNKNOW, then the @p
- * group_type will speficy if it is a list (#EET_G_LIST),
+ * group_type will specify if it is a list (#EET_G_LIST),
* array (#EET_G_ARRAY) and so on. If #EET_G_UNKNOWN, then
* the member is a subtype (pointer to another type defined by
* another #Eet_Data_Descriptor).
*/
EAPI void
eet_data_descriptor_element_add(Eet_Data_Descriptor *edd,
- const char *name,
- int type,
- int group_type,
- int offset,
- /* int count_offset, */
- int count,
- const char *counter_name,
+ const char *name,
+ int type,
+ int group_type,
+ int offset,
+ /* int count_offset, */
+ int count,
+ const char *counter_name,
Eet_Data_Descriptor *subtype);
/**
* @ingroup Eet_Data_Group
*/
EAPI void *
-eet_data_read(Eet_File *ef,
+eet_data_read(Eet_File *ef,
Eet_Data_Descriptor *edd,
- const char *name);
+ const char *name);
/**
* Write a data structure from memory and store in an eet file.
* @param ef The eet file handle to write to.
* @param edd The data descriptor to use when encoding.
* @param name The key to store the data under in the eet file.
- * @param data A pointer to the data structure to ssave and encode.
+ * @param data A pointer to the data structure to save and encode.
* @param compress Compression flags for storage.
* @return bytes written on successful write, 0 on failure.
*
* @ingroup Eet_Data_Group
*/
EAPI int
-eet_data_write(Eet_File *ef,
+eet_data_write(Eet_File *ef,
Eet_Data_Descriptor *edd,
- const char *name,
- const void *data,
- int compress);
+ const char *name,
+ const void *data,
+ int compress);
typedef void (*Eet_Dump_Callback)(void *data, const char *str);
* @ingroup Eet_Data_Group
*/
EAPI int
-eet_data_text_dump(const void *data_in,
- int size_in,
+eet_data_text_dump(const void *data_in,
+ int size_in,
Eet_Dump_Callback dumpfunc,
- void *dumpdata);
+ void *dumpdata);
/**
* Take an ascii encoding from eet_data_text_dump() and re-encode in binary.
*/
EAPI void *
eet_data_text_undump(const char *text,
- int textlen,
- int *size_ret);
+ int textlen,
+ int *size_ret);
/**
* Dump an eet encoded data structure from an eet file into ascii text
* @ingroup Eet_Data_Group
*/
EAPI int
-eet_data_dump(Eet_File *ef,
- const char *name,
+eet_data_dump(Eet_File *ef,
+ const char *name,
Eet_Dump_Callback dumpfunc,
- void *dumpdata);
+ void *dumpdata);
/**
* Take an ascii encoding from eet_data_dump() and re-encode in binary.
* @ingroup Eet_Data_Group
*/
EAPI int
-eet_data_undump(Eet_File *ef,
+eet_data_undump(Eet_File *ef,
const char *name,
const char *text,
- int textlen,
- int compress);
+ int textlen,
+ int compress);
/**
* Decode a data structure from an arbitrary location in memory.
*/
EAPI void *
eet_data_descriptor_decode(Eet_Data_Descriptor *edd,
- const void *data_in,
- int size_in);
+ const void *data_in,
+ int size_in);
/**
* Encode a dsata struct to memory and return that encoded data.
* 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.
+ * 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
*/
EAPI void *
eet_data_descriptor_encode(Eet_Data_Descriptor *edd,
- const void *data_in,
- int *size_ret);
+ const void *data_in,
+ int *size_ret);
/**
* Add a basic data element to a data descriptor.
* @ingroup Eet_Data_Group
*/
#define EET_DATA_DESCRIPTOR_ADD_BASIC(edd, struct_type, name, member, type) \
- do { \
- struct_type ___ett; \
- eet_data_descriptor_element_add(edd, name, type, EET_G_UNKNOWN, \
- (char *)(& (___ett.member)) - \
- (char *)(& (___ett)), \
- 0, /* 0, */ NULL, NULL); \
- } while(0)
+ do { \
+ struct_type ___ett; \
+ eet_data_descriptor_element_add(edd, name, type, EET_G_UNKNOWN, \
+ (char *)(& (___ett.member)) - \
+ (char *)(& (___ett)), \
+ 0, /* 0, */ NULL, NULL); \
+ } while(0)
/**
* Add a sub-element type to a data descriptor
* @since 1.0.0
* @ingroup Eet_Data_Group
*/
-#define EET_DATA_DESCRIPTOR_ADD_SUB(edd, struct_type, name, member, subtype) \
- do { \
- struct_type ___ett; \
- eet_data_descriptor_element_add(edd, name, EET_T_UNKNOW, EET_G_UNKNOWN, \
- (char *)(& (___ett.member)) - \
- (char *)(& (___ett)), \
- 0, /* 0, */ NULL, subtype); \
- } while (0)
+#define EET_DATA_DESCRIPTOR_ADD_SUB(edd, struct_type, name, member, subtype) \
+ do { \
+ struct_type ___ett; \
+ eet_data_descriptor_element_add(edd, name, EET_T_UNKNOW, EET_G_UNKNOWN, \
+ (char *)(& (___ett.member)) - \
+ (char *)(& (___ett)), \
+ 0, /* 0, */ NULL, subtype); \
+ } while (0)
/**
* Add a linked list type to a data descriptor
* @ingroup Eet_Data_Group
*/
#define EET_DATA_DESCRIPTOR_ADD_LIST(edd, struct_type, name, member, subtype) \
- do { \
- struct_type ___ett; \
- eet_data_descriptor_element_add(edd, name, EET_T_UNKNOW, EET_G_LIST, \
- (char *)(& (___ett.member)) - \
- (char *)(& (___ett)), \
- 0, /* 0, */ NULL, subtype); \
- } while (0)
+ do { \
+ struct_type ___ett; \
+ eet_data_descriptor_element_add(edd, name, EET_T_UNKNOW, EET_G_LIST, \
+ (char *)(& (___ett.member)) - \
+ (char *)(& (___ett)), \
+ 0, /* 0, */ NULL, subtype); \
+ } while (0)
/**
* Add a linked list of string to a data descriptor
* @ingroup Eet_Data_Group
*/
#define EET_DATA_DESCRIPTOR_ADD_LIST_STRING(edd, struct_type, name, member) \
- do { \
- struct_type ___ett; \
- eet_data_descriptor_element_add(edd, name, EET_T_STRING, EET_G_LIST, \
- (char *)(& (___ett.member)) - \
- (char *)(& (___ett)), \
- 0, /* 0, */ NULL, NULL); \
- } while (0)
+ do { \
+ struct_type ___ett; \
+ eet_data_descriptor_element_add(edd, name, EET_T_STRING, EET_G_LIST, \
+ (char *)(& (___ett.member)) - \
+ (char *)(& (___ett)), \
+ 0, /* 0, */ NULL, NULL); \
+ } while (0)
/**
* Add a hash type to a data descriptor
* @ingroup Eet_Data_Group
*/
#define EET_DATA_DESCRIPTOR_ADD_HASH(edd, struct_type, name, member, subtype) \
- do { \
- struct_type ___ett; \
- eet_data_descriptor_element_add(edd, name, EET_T_UNKNOW, EET_G_HASH, \
- (char *)(& (___ett.member)) - \
- (char *)(& (___ett)), \
- 0, /* 0, */ NULL, subtype); \
- } while (0)
+ do { \
+ struct_type ___ett; \
+ eet_data_descriptor_element_add(edd, name, EET_T_UNKNOW, EET_G_HASH, \
+ (char *)(& (___ett.member)) - \
+ (char *)(& (___ett)), \
+ 0, /* 0, */ NULL, subtype); \
+ } while (0)
/**
* Add a hash of string to a data descriptor
* @ingroup Eet_Data_Group
*/
#define EET_DATA_DESCRIPTOR_ADD_HASH_STRING(edd, struct_type, name, member) \
- do { \
- struct_type ___ett; \
- eet_data_descriptor_element_add(edd, name, EET_T_STRING, EET_G_HASH, \
- (char *)(& (___ett.member)) - \
- (char *)(& (___ett)), \
- 0, /* 0, */ NULL, NULL); \
- } while (0)
+ do { \
+ struct_type ___ett; \
+ eet_data_descriptor_element_add(edd, name, EET_T_STRING, EET_G_HASH, \
+ (char *)(& (___ett.member)) - \
+ (char *)(& (___ett)), \
+ 0, /* 0, */ NULL, NULL); \
+ } while (0)
+
+/**
+ * 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
+ * @ingroup Eet_Data_Group
+ */
+#define EET_DATA_DESCRIPTOR_ADD_BASIC_ARRAY(edd, struct_type, name, member, type) \
+ do { \
+ struct_type ___ett; \
+ eet_data_descriptor_element_add(edd, name, type, EET_G_ARRAY, \
+ (char *)(& (___ett.member)) - \
+ (char *)(& (___ett)), \
+ sizeof(___ett.member) / \
+ sizeof(___ett.member[0]), \
+ NULL, NULL); \
+ } while(0)
+
+/**
+ * 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
+ * @ingroup Eet_Data_Group
+ */
+#define EET_DATA_DESCRIPTOR_ADD_BASIC_VAR_ARRAY(edd, struct_type, name, member, type) \
+ do { \
+ struct_type ___ett; \
+ eet_data_descriptor_element_add(edd, name, type, EET_G_VAR_ARRAY, \
+ (char *)(& (___ett.member)) - \
+ (char *)(& (___ett)), \
+ (char *)(& (___ett.member ## _count)) - \
+ (char *)(& (___ett)), \
+ NULL, \
+ NULL); \
+ } while(0)
/**
* Add a fixed size array type to a data descriptor
* @since 1.0.2
* @ingroup Eet_Data_Group
*/
-#define EET_DATA_DESCRIPTOR_ADD_ARRAY(edd, struct_type, name, member, subtype) \
- do { \
- struct_type ___ett; \
- eet_data_descriptor_element_add(edd, name, EET_T_UNKNOW, EET_G_ARRAY, \
- (char *)(& (___ett.member)) - \
- (char *)(& (___ett)), \
- /* 0, */ sizeof(___ett.member) / \
- sizeof(___ett.member[0]), NULL, subtype); \
- } while (0)
+#define EET_DATA_DESCRIPTOR_ADD_ARRAY(edd, struct_type, name, member, subtype) \
+ do { \
+ struct_type ___ett; \
+ eet_data_descriptor_element_add(edd, name, EET_T_UNKNOW, EET_G_ARRAY, \
+ (char *)(& (___ett.member)) - \
+ (char *)(& (___ett)), \
+ /* 0, */ sizeof(___ett.member) / \
+ sizeof(___ett.member[0]), NULL, subtype); \
+ } while (0)
/**
* Add a variable size array type to a data descriptor
* @ingroup Eet_Data_Group
*/
#define EET_DATA_DESCRIPTOR_ADD_VAR_ARRAY(edd, struct_type, name, member, subtype) \
- do { \
- struct_type ___ett; \
- eet_data_descriptor_element_add(edd, \
- name, \
- EET_T_UNKNOW, \
- EET_G_VAR_ARRAY, \
- (char *)(& (___ett.member)) - \
- (char *)(& (___ett)), \
- (char *)(& (___ett.member ## _count)) - \
- (char *)(& (___ett)), \
- /* 0, */ NULL, \
- subtype); \
- } while (0)
+ do { \
+ struct_type ___ett; \
+ eet_data_descriptor_element_add(edd, \
+ name, \
+ EET_T_UNKNOW, \
+ EET_G_VAR_ARRAY, \
+ (char *)(& (___ett.member)) - \
+ (char *)(& (___ett)), \
+ (char *)(& (___ett.member ## _count)) - \
+ (char *)(& (___ett)), \
+ /* 0, */ NULL, \
+ subtype); \
+ } while (0)
/**
* Add a variable size array type to a data descriptor
* @ingroup Eet_Data_Group
*/
#define EET_DATA_DESCRIPTOR_ADD_VAR_ARRAY_STRING(edd, struct_type, name, member) \
- do { \
- struct_type ___ett; \
- eet_data_descriptor_element_add(edd, \
- name, \
- EET_T_STRING, \
- EET_G_VAR_ARRAY, \
- (char *)(& (___ett.member)) - \
- (char *)(& (___ett)), \
- (char *)(& (___ett.member ## _count)) - \
- (char *)(& (___ett)), \
- /* 0, */ NULL, \
- NULL); \
- } while (0)
+ do { \
+ struct_type ___ett; \
+ eet_data_descriptor_element_add(edd, \
+ name, \
+ EET_T_STRING, \
+ EET_G_VAR_ARRAY, \
+ (char *)(& (___ett.member)) - \
+ (char *)(& (___ett)), \
+ (char *)(& (___ett.member ## _count)) - \
+ (char *)(& (___ett)), \
+ /* 0, */ NULL, \
+ NULL); \
+ } while (0)
/**
* Add an union type to a data descriptor
* @see Eet_Data_Descriptor_Class
*/
#define EET_DATA_DESCRIPTOR_ADD_UNION(edd, struct_type, name, member, type_member, unified_type) \
- do { \
- struct_type ___ett; \
- eet_data_descriptor_element_add(edd, name, EET_T_UNKNOW, EET_G_UNION, \
- (char *)(& (___ett.member)) - \
- (char *)(& (___ett)), \
- (char *)(& (___ett.type_member)) - \
- (char *)(& (___ett)), \
- NULL, unified_type); \
- } while (0)
+ do { \
+ struct_type ___ett; \
+ eet_data_descriptor_element_add(edd, name, EET_T_UNKNOW, EET_G_UNION, \
+ (char *)(& (___ett.member)) - \
+ (char *)(& (___ett)), \
+ (char *)(& (___ett.type_member)) - \
+ (char *)(& (___ett)), \
+ NULL, unified_type); \
+ } while (0)
/**
* Add a automatically selectable type to a data descriptor
* @see Eet_Data_Descriptor_Class
*/
#define EET_DATA_DESCRIPTOR_ADD_VARIANT(edd, struct_type, name, member, type_member, unified_type) \
- do { \
- struct_type ___ett; \
- eet_data_descriptor_element_add(edd, name, EET_T_UNKNOW, EET_G_VARIANT, \
- (char *)(& (___ett.member)) - \
- (char *)(& (___ett)), \
- (char *)(& (___ett.type_member)) - \
- (char *)(& (___ett)), \
- NULL, unified_type); \
- } while (0)
+ do { \
+ struct_type ___ett; \
+ eet_data_descriptor_element_add(edd, name, EET_T_UNKNOW, EET_G_VARIANT, \
+ (char *)(& (___ett.member)) - \
+ (char *)(& (___ett)), \
+ (char *)(& (___ett.type_member)) - \
+ (char *)(& (___ett)), \
+ NULL, unified_type); \
+ } while (0)
/**
* Add a mapping to a data descriptor that will be used by union, variant or inherited type
* @see Eet_Data_Descriptor_Class
*/
#define EET_DATA_DESCRIPTOR_ADD_MAPPING(unified_type, name, subtype) \
- eet_data_descriptor_element_add(unified_type, \
- name, \
- EET_T_UNKNOW, \
- EET_G_UNKNOWN, \
- 0, \
- 0, \
- NULL, \
- subtype)
+ eet_data_descriptor_element_add(unified_type, \
+ name, \
+ EET_T_UNKNOW, \
+ EET_G_UNKNOWN, \
+ 0, \
+ 0, \
+ NULL, \
+ subtype)
/**
* @defgroup Eet_Data_Cipher_Group Eet Data Serialization using A Ciphers
* @ingroup Eet_Data_Cipher_Group
*/
EAPI void *
-eet_data_read_cipher(Eet_File *ef,
+eet_data_read_cipher(Eet_File *ef,
Eet_Data_Descriptor *edd,
- const char *name,
- const char *cipher_key);
+ const char *name,
+ const char *cipher_key);
/**
* Read a data structure from an eet extended attribute and decodes it using a cipher.
*/
EAPI void *
eet_data_xattr_cipher_get(const char *filename,
- const char *attribute,
- Eet_Data_Descriptor *edd,
- const char *cipher_key);
+ const char *attribute,
+ Eet_Data_Descriptor *edd,
+ const char *cipher_key);
/**
* Write a data structure from memory and store in an eet file
* @param edd The data descriptor to use when encoding.
* @param name The key to store the data under in the eet file.
* @param cipher_key The key to use as cipher.
- * @param data A pointer to the data structure to ssave and encode.
+ * @param data A pointer to the data structure to save and encode.
* @param compress Compression flags for storage.
* @return bytes written on successful write, 0 on failure.
*
* @ingroup Eet_Data_Cipher_Group
*/
EAPI int
-eet_data_write_cipher(Eet_File *ef,
+eet_data_write_cipher(Eet_File *ef,
Eet_Data_Descriptor *edd,
- const char *name,
- const char *cipher_key,
- const void *data,
- int compress);
+ const char *name,
+ const char *cipher_key,
+ const void *data,
+ int compress);
/**
* Write a data structure from memory and store in an eet extended attribute
* @param attribute The attribute to store the data to.
* @param edd The data descriptor to use when encoding.
* @param cipher_key The key to use as cipher.
- * @param data A pointer to the data structure to ssave and encode.
+ * @param data A pointer to the data structure to save and encode.
* @param flags The policy to use when setting the data.
* @return EINA_TRUE on success, EINA_FALSE on failure.
*
*/
EAPI Eina_Bool
eet_data_xattr_cipher_set(const char *filename,
- const char *attribute,
- Eet_Data_Descriptor *edd,
- const char *cipher_key,
- const void *data,
- Eina_Xattr_Flags flags);
+ const char *attribute,
+ Eet_Data_Descriptor *edd,
+ const char *cipher_key,
+ const void *data,
+ Eina_Xattr_Flags flags);
/**
* Dump an eet encoded data structure into ascii text using a cipher.
EAPI void *
eet_data_text_undump_cipher(const char *text,
const char *cipher_key,
- int textlen,
- int *size_ret);
+ int textlen,
+ int *size_ret);
/**
* Dump an eet encoded data structure from an eet file into ascii
* @ingroup Eet_Data_Cipher_Group
*/
EAPI int
-eet_data_dump_cipher(Eet_File *ef,
- const char *name,
- const char *cipher_key,
+eet_data_dump_cipher(Eet_File *ef,
+ const char *name,
+ const char *cipher_key,
Eet_Dump_Callback dumpfunc,
- void *dumpdata);
+ void *dumpdata);
/**
* Take an ascii encoding from eet_data_dump() and re-encode in
* @ingroup Eet_Data_Cipher_Group
*/
EAPI int
-eet_data_undump_cipher(Eet_File *ef,
+eet_data_undump_cipher(Eet_File *ef,
const char *name,
const char *cipher_key,
const char *text,
- int textlen,
- int compress);
+ int textlen,
+ int compress);
/**
* Decode a data structure from an arbitrary location in memory
*/
EAPI void *
eet_data_descriptor_decode_cipher(Eet_Data_Descriptor *edd,
- const void *data_in,
- const char *cipher_key,
- int size_in);
+ const void *data_in,
+ const char *cipher_key,
+ int size_in);
/**
* Encode a data struct to memory and return that encoded data
*/
EAPI void *
eet_data_descriptor_encode_cipher(Eet_Data_Descriptor *edd,
- const void *data_in,
- const char *cipher_key,
- int *size_ret);
+ const void *data_in,
+ const char *cipher_key,
+ int *size_ret);
/**
* @defgroup Eet_Node_Group Low-level Serialization Structures.
* @typedef Eet_Node
* Opaque handle to manage serialization node.
*/
-typedef struct _Eet_Node Eet_Node;
+typedef struct _Eet_Node Eet_Node;
/**
* @typedef Eet_Node_Data
* Contains an union that can fit any kind of node.
*/
-typedef struct _Eet_Node_Data Eet_Node_Data;
+typedef struct _Eet_Node_Data Eet_Node_Data;
/**
* @struct _Eet_Node_Data
struct _Eet_Node_Data
{
union {
- char c;
- short s;
- int i;
- long long l;
- float f;
- double d;
- unsigned char uc;
- unsigned short us;
- unsigned int ui;
- unsigned long long ul;
- const char *str;
+ char c;
+ short s;
+ int i;
+ long long l;
+ float f;
+ double d;
+ unsigned char uc;
+ unsigned short us;
+ unsigned int ui;
+ unsigned long long ul;
+ const char *str;
} value;
};
* @ingroup Eet_Node_Group
*/
EAPI Eet_Node *
- eet_node_char_new(const char *name,
- char c);
+eet_node_char_new(const char *name,
+ char c);
/**
* TODO FIX ME
*/
EAPI Eet_Node *
eet_node_short_new(const char *name,
- short s);
+ short s);
/**
* TODO FIX ME
*/
EAPI Eet_Node *
eet_node_int_new(const char *name,
- int i);
+ int i);
/**
* TODO FIX ME
*/
EAPI Eet_Node *
eet_node_long_long_new(const char *name,
- long long l);
+ long long l);
/**
* TODO FIX ME
*/
EAPI Eet_Node *
eet_node_float_new(const char *name,
- float f);
+ float f);
/**
* TODO FIX ME
*/
EAPI Eet_Node *
eet_node_double_new(const char *name,
- double d);
+ double d);
/**
* TODO FIX ME
* @ingroup Eet_Node_Group
*/
EAPI Eet_Node *
-eet_node_unsigned_char_new(const char *name,
- unsigned char uc);
+eet_node_unsigned_char_new(const char *name,
+ unsigned char uc);
/**
* TODO FIX ME
* @ingroup Eet_Node_Group
*/
EAPI Eet_Node *
-eet_node_unsigned_short_new(const char *name,
- unsigned short us);
+eet_node_unsigned_short_new(const char *name,
+ unsigned short us);
/**
* TODO FIX ME
* @ingroup Eet_Node_Group
*/
EAPI Eet_Node *
-eet_node_unsigned_int_new(const char *name,
- unsigned int ui);
+eet_node_unsigned_int_new(const char *name,
+ unsigned int ui);
/**
* TODO FIX ME
* @ingroup Eet_Node_Group
*/
EAPI Eet_Node *
-eet_node_unsigned_long_long_new(const char *name,
- unsigned long long l);
+eet_node_unsigned_long_long_new(const char *name,
+ unsigned long long l);
/**
* TODO FIX ME
*/
EAPI Eet_Node *
eet_node_list_new(const char *name,
- Eina_List *nodes);
+ Eina_List *nodes);
/**
* TODO FIX ME
*/
EAPI Eet_Node *
eet_node_array_new(const char *name,
- int count,
- Eina_List *nodes);
+ int count,
+ Eina_List *nodes);
/**
* TODO FIX ME
*/
EAPI Eet_Node *
eet_node_var_array_new(const char *name,
- Eina_List *nodes);
+ Eina_List *nodes);
/**
* TODO FIX ME
EAPI Eet_Node *
eet_node_hash_new(const char *name,
const char *key,
- Eet_Node *node);
+ Eet_Node *node);
/**
* TODO FIX ME
*/
EAPI Eet_Node *
eet_node_struct_new(const char *name,
- Eina_List *nodes);
+ Eina_List *nodes);
/**
* TODO FIX ME
*/
EAPI Eet_Node *
eet_node_struct_child_new(const char *parent,
- Eet_Node *child);
+ Eet_Node *child);
/**
* @brief Get a node's child nodes
* @ingroup Eet_Node_Group
*/
EAPI void
-eet_node_list_append(Eet_Node *parent,
+eet_node_list_append(Eet_Node *parent,
const char *name,
- Eet_Node *child);
+ Eet_Node *child);
/**
* TODO FIX ME
* @ingroup Eet_Node_Group
*/
EAPI void
-eet_node_struct_append(Eet_Node *parent,
+eet_node_struct_append(Eet_Node *parent,
const char *name,
- Eet_Node *child);
+ Eet_Node *child);
/**
* TODO FIX ME
* @ingroup Eet_Node_Group
*/
EAPI void
-eet_node_hash_add(Eet_Node *parent,
+eet_node_hash_add(Eet_Node *parent,
const char *name,
const char *key,
- Eet_Node *child);
+ Eet_Node *child);
/**
* TODO FIX ME
* @ingroup Eet_Node_Group
*/
EAPI void
-eet_node_dump(Eet_Node *n,
- int dumplevel,
+eet_node_dump(Eet_Node *n,
+ int dumplevel,
Eet_Dump_Callback dumpfunc,
- void *dumpdata);
+ void *dumpdata);
/**
* @brief Return the type of a node
* @ingroup Eet_Node_Group
*/
EAPI void *
-eet_data_node_encode_cipher(Eet_Node *node,
+eet_data_node_encode_cipher(Eet_Node *node,
const char *cipher_key,
- int *size_ret);
+ int *size_ret);
/**
* TODO FIX ME
EAPI Eet_Node *
eet_data_node_decode_cipher(const void *data_in,
const char *cipher_key,
- int size_in);
+ int size_in);
/**
* TODO FIX ME
* @ingroup Eet_Node_Group
*/
EAPI Eet_Node *
-eet_data_node_read_cipher(Eet_File *ef,
+eet_data_node_read_cipher(Eet_File *ef,
const char *name,
const char *cipher_key);
* @ingroup Eet_Node_Group
*/
EAPI int
-eet_data_node_write_cipher(Eet_File *ef,
+eet_data_node_write_cipher(Eet_File *ef,
const char *name,
const char *cipher_key,
- Eet_Node *node,
- int compress);
+ Eet_Node *node,
+ int compress);
/* EXPERIMENTAL: THIS API MAY CHANGE IN THE FUTURE, USE IT ONLY IF YOU KNOW WHAT YOU ARE DOING. */
* @typedef Eet_Node_Walk
* Describes how to walk trees of #Eet_Node.
*/
-typedef struct _Eet_Node_Walk Eet_Node_Walk;
+typedef struct _Eet_Node_Walk Eet_Node_Walk;
-typedef void *(*Eet_Node_Walk_Struct_Alloc_Callback)(const char *type, void *user_data);
-typedef void (*Eet_Node_Walk_Struct_Add_Callback)(void *parent, const char *name, void *child, void *user_data);
-typedef void *(*Eet_Node_Walk_Array_Callback)(Eina_Bool variable, const char *name, int count, void *user_data);
-typedef void (*Eet_Node_Walk_Insert_Callback)(void *array, int index, void *child, void *user_data);
-typedef void *(*Eet_Node_Walk_List_Callback)(const char *name, void *user_data);
-typedef void (*Eet_Node_Walk_Append_Callback)(void *list, void *child, void *user_data);
-typedef void *(*Eet_Node_Walk_Hash_Callback)(void *parent, const char *name, const char *key, void *value, void *user_data);
-typedef void *(*Eet_Node_Walk_Simple_Callback)(int type, Eet_Node_Data *data, void *user_data);
+typedef void * (*Eet_Node_Walk_Struct_Alloc_Callback)(const char *type, void *user_data);
+typedef void (*Eet_Node_Walk_Struct_Add_Callback)(void *parent, const char *name, void *child, void *user_data);
+typedef void * (*Eet_Node_Walk_Array_Callback)(Eina_Bool variable, const char *name, int count, void *user_data);
+typedef void (*Eet_Node_Walk_Insert_Callback)(void *array, int index, void *child, void *user_data);
+typedef void * (*Eet_Node_Walk_List_Callback)(const char *name, void *user_data);
+typedef void (*Eet_Node_Walk_Append_Callback)(void *list, void *child, void *user_data);
+typedef void * (*Eet_Node_Walk_Hash_Callback)(void *parent, const char *name, const char *key, void *value, void *user_data);
+typedef void * (*Eet_Node_Walk_Simple_Callback)(int type, Eet_Node_Data *data, void *user_data);
/**
* @struct _Eet_Node_Walk
struct _Eet_Node_Walk
{
Eet_Node_Walk_Struct_Alloc_Callback struct_alloc;
- Eet_Node_Walk_Struct_Add_Callback struct_add;
- Eet_Node_Walk_Array_Callback array;
- Eet_Node_Walk_Insert_Callback insert;
- Eet_Node_Walk_List_Callback list;
- Eet_Node_Walk_Append_Callback append;
- Eet_Node_Walk_Hash_Callback hash;
- Eet_Node_Walk_Simple_Callback simple;
+ Eet_Node_Walk_Struct_Add_Callback struct_add;
+ Eet_Node_Walk_Array_Callback array;
+ Eet_Node_Walk_Insert_Callback insert;
+ Eet_Node_Walk_List_Callback list;
+ Eet_Node_Walk_Append_Callback append;
+ Eet_Node_Walk_Hash_Callback hash;
+ Eet_Node_Walk_Simple_Callback simple;
};
EAPI void *
-eet_node_walk(void *parent,
- const char *name,
- Eet_Node *root,
+eet_node_walk(void *parent,
+ const char *name,
+ Eet_Node *root,
Eet_Node_Walk *cb,
- void *user_data);
+ void *user_data);
/*******/
*
* @ingroup Eet_Connection_Group
*/
-typedef struct _Eet_Connection Eet_Connection;
+typedef struct _Eet_Connection Eet_Connection;
/**
* @typedef Eet_Read_Cb
- * Called back when an @ref Eet_Data_Group has been received completly and could be used.
+ * Called back when an @ref Eet_Data_Group has been received completely and could be used.
*
* @ingroup Eet_Connection_Group
*/
* @ingroup Eet_Connection_Group
*/
EAPI Eet_Connection *
-eet_connection_new(Eet_Read_Cb *eet_read_cb,
+eet_connection_new(Eet_Read_Cb *eet_read_cb,
Eet_Write_Cb *eet_write_cb,
- const void *user_data);
+ const void *user_data);
/**
* Process a raw packet received over the link
*/
EAPI int
eet_connection_received(Eet_Connection *conn,
- const void *data,
- size_t size);
+ const void *data,
+ size_t size);
/**
* Convert a complex structure and prepare it to be send.
* @ingroup Eet_Connection_Group
*/
EAPI Eina_Bool
-eet_connection_send(Eet_Connection *conn,
+eet_connection_send(Eet_Connection *conn,
Eet_Data_Descriptor *edd,
- const void *data_in,
- const char *cipher_key);
+ const void *data_in,
+ const char *cipher_key);
/**
* Convert a Eet_Node tree and prepare it to be send.
*/
EAPI Eina_Bool
eet_connection_node_send(Eet_Connection *conn,
- Eet_Node *node,
- const char *cipher_key);
+ Eet_Node *node,
+ const char *cipher_key);
/**
* Close a connection and lost its track.
*/
EAPI void *
eet_connection_close(Eet_Connection *conn,
- Eina_Bool *on_going);
+ Eina_Bool *on_going);
/***************************************************************************/
projects / framework / uifw / eet.git / blobdiff