forked from enlightenment/efl
eina: fix spelling errors in documentation
Reviewers: cedric, ajwillia.ms Reviewed By: cedric Subscribers: segfaultxavi, jpeg Differential Revision: https://phab.enlightenment.org/D5395 Signed-off-by: Cedric Bail <cedric@osg.samsung.com>
This commit is contained in:
parent
b550581dde
commit
6ac4497162
|
@ -43,7 +43,7 @@
|
|||
* Here we have a callback that prints the element given to it:
|
||||
* @until }
|
||||
*
|
||||
* Now we create our entry point and declare some variables, nothing especial:
|
||||
* Now we create our entry point and declare some variables, nothing special:
|
||||
* @until unsigned
|
||||
*
|
||||
* Before we can start using any array function we need to initialize eina:
|
||||
|
@ -262,7 +262,7 @@ EAPI Eina_Array *eina_array_new(unsigned int step) EINA_WARN_UNUSED_RESULT EINA_
|
|||
* @param array The array to free.
|
||||
*
|
||||
* This function frees @p array. It calls first eina_array_flush() then
|
||||
* free the memory of the pointer. It does not free the memory
|
||||
* frees the memory of the pointer. It does not free the memory
|
||||
* allocated for the elements of @p array. To free them, walk the array with
|
||||
* #EINA_ARRAY_ITER_NEXT.
|
||||
*/
|
||||
|
@ -316,7 +316,7 @@ EAPI void eina_array_flush(Eina_Array *array) EINA_ARG_NONNULL(1);
|
|||
* @param gdata The data to pass to the function keep.
|
||||
* @return #EINA_TRUE on success, #EINA_FALSE otherwise.
|
||||
*
|
||||
* This function rebuilds @p array be specifying the elements to keep with the
|
||||
* This function rebuilds @p array by specifying the elements to keep with the
|
||||
* function @p keep. No empty/invalid fields are left in the array. @p gdata is
|
||||
* an additional data to pass to @p keep. For performance reasons, there is no
|
||||
* check of @p array. If it is @c NULL or invalid, the program may crash.
|
||||
|
@ -414,7 +414,7 @@ static inline unsigned int eina_array_count_get(const Eina_Array *array) EINA_AR
|
|||
static inline unsigned int eina_array_count(const Eina_Array *array) EINA_ARG_NONNULL(1) EINA_WARN_UNUSED_RESULT;
|
||||
|
||||
/**
|
||||
* @brief Gets a new iterator associated to an array.
|
||||
* @brief Gets a new iterator associated with an array.
|
||||
*
|
||||
* @param array The array.
|
||||
* @return A new iterator.
|
||||
|
@ -427,7 +427,7 @@ static inline unsigned int eina_array_count(const Eina_Array *array) EINA_ARG_NO
|
|||
EAPI Eina_Iterator *eina_array_iterator_new(const Eina_Array *array) EINA_MALLOC EINA_ARG_NONNULL(1) EINA_WARN_UNUSED_RESULT;
|
||||
|
||||
/**
|
||||
* @brief Gets a new accessor associated to an array.
|
||||
* @brief Gets a new accessor associated with an array.
|
||||
*
|
||||
* @param array The array.
|
||||
* @return A new accessor.
|
||||
|
@ -445,7 +445,7 @@ EAPI Eina_Accessor *eina_array_accessor_new(const Eina_Array *array) EINA
|
|||
* @param array The array to iterate over.
|
||||
* @param cb The callback to call for each item.
|
||||
* @param fdata The user data to pass to the callback.
|
||||
* @return #EINA_TRUE if it successfully iterate all items of the array.
|
||||
* @return #EINA_TRUE if it successfully iterated all items of the array.
|
||||
*
|
||||
* This function provides a safe way to iterate over an array. @p cb should
|
||||
* return #EINA_TRUE as long as you want the function to continue iterating.
|
||||
|
|
|
@ -27,9 +27,9 @@
|
|||
* @page tutorial_benchmark_page Benchmark Tutorial
|
||||
*
|
||||
* The Benchmark module allows you to write easily benchmarks
|
||||
* framework in a project for timing critical part and detect slow
|
||||
* framework to a project for timing critical parts and detecting slow
|
||||
* parts of code. In addition it automatically creates data files of
|
||||
* these benchmark, as well as a gnuplot file which can display the
|
||||
* these benchmarks, as well as a gnuplot file which can display the
|
||||
* comparison curves of the benchmarks.
|
||||
*
|
||||
* @section tutorial_benchmark_basic_usage Basic Usage
|
||||
|
@ -116,7 +116,7 @@
|
|||
* The first column (specimen) is the integer passed to the work1()
|
||||
* function when the test is run. The second column (experiment time)
|
||||
* is the time, in nanosecond, that work1() takes. The third and
|
||||
* fourth column are self-explicit.
|
||||
* fourth columns are self-explicit.
|
||||
*
|
||||
* You can see that the integer passed work1() starts from 200 and
|
||||
* finishes at 290, with a step of 10. These values are computed withe
|
||||
|
@ -297,8 +297,8 @@
|
|||
/**
|
||||
* @addtogroup Eina_Benchmark_Group Benchmark
|
||||
*
|
||||
* These functions allow you to add benchmark framework in a project
|
||||
* for timing critical part and detect slow parts of code. It is used
|
||||
* These functions allow you to add a benchmark framework to a project
|
||||
* for timing critical parts and detecting slow parts of code. It is used
|
||||
* in Eina to compare the time used by eina, glib, evas and ecore data
|
||||
* types.
|
||||
*
|
||||
|
@ -364,9 +364,9 @@ typedef void (*Eina_Benchmark_Specimens)(int request);
|
|||
* This function creates a new benchmark. @p name and @p run are used
|
||||
* to name the gnuplot file that eina_benchmark_run() will create.
|
||||
*
|
||||
* This function return a valid benchmark on success, or @c NULL if
|
||||
* This function returns a valid benchmark on success, or @c NULL if
|
||||
* memory allocation fails.
|
||||
*
|
||||
*
|
||||
* When the new module is not needed anymore, use
|
||||
* eina_benchmark_free() to free the allocated memory.
|
||||
*/
|
||||
|
@ -418,8 +418,8 @@ EAPI Eina_Bool eina_benchmark_register(Eina_Benchmark *bench,
|
|||
* @param bench The benchmark.
|
||||
* @return The list of names of the test files.
|
||||
*
|
||||
* This function runs all the tests that as been registered with
|
||||
* eina_benchmark_register() and save the result in a gnuplot
|
||||
* This function runs all the tests that have been registered with
|
||||
* eina_benchmark_register() and saves the result in a gnuplot
|
||||
* file. The name of the file has the following format:
|
||||
*
|
||||
* @code
|
||||
|
|
|
@ -144,7 +144,7 @@ EAPI double eina_bezier_angle_at(const Eina_Bezier *b, double t) EINA_ARG_NONNUL
|
|||
EAPI void eina_bezier_split_at_length(const Eina_Bezier *b, double len, Eina_Bezier *left, Eina_Bezier *right) EINA_ARG_NONNULL(1);
|
||||
|
||||
/**
|
||||
* @brief Gets the bound of the the bezier.
|
||||
* @brief Gets the bounds of the bezier.
|
||||
*
|
||||
* @param b The floating point bezier.
|
||||
* @param x x coordinate of bounding box.
|
||||
|
@ -158,7 +158,7 @@ EAPI void eina_bezier_split_at_length(const Eina_Bezier *b, double len, Eina_Bez
|
|||
EAPI void eina_bezier_bounds_get(const Eina_Bezier *b, double *x, double *y, double *w, double *h) EINA_ARG_NONNULL(1);
|
||||
|
||||
/**
|
||||
* @brief Finds the bezier at given interval.
|
||||
* @brief Finds the bezier at the given interval.
|
||||
*
|
||||
* @param b The floating point bezier.
|
||||
* @param t0 The start interval.
|
||||
|
|
|
@ -10,7 +10,7 @@
|
|||
/**
|
||||
* @addtogroup Eina_Binary_Buffer_Group Binary Buffer
|
||||
*
|
||||
* @brief These functions provide string buffers management.
|
||||
* @brief These functions provide string buffer management.
|
||||
*
|
||||
* The Binary Buffer data type is designed to be a mutable string,
|
||||
* allowing to append, prepend or insert a string to a buffer.
|
||||
|
@ -125,8 +125,8 @@ EAPI void eina_binbuf_free(Eina_Binbuf *buf) EINA_ARG_NONNULL(1);
|
|||
*
|
||||
* @param buf The string buffer to reset.
|
||||
*
|
||||
* This function reset @p buf: the buffer len is set to 0, and the
|
||||
* string is set to '\\0'. No memory is free'd.
|
||||
* This function resets @p buf: the buffer len is set to 0, and the
|
||||
* string is set to '\\0'. No memory is freed.
|
||||
*/
|
||||
EAPI void eina_binbuf_reset(Eina_Binbuf *buf) EINA_ARG_NONNULL(1);
|
||||
|
||||
|
@ -193,7 +193,7 @@ EAPI Eina_Bool eina_binbuf_use(Eina_Binbuf *buf, size_t extra_bytes) EINA_ARG_NO
|
|||
* This function appends @p str to @p buf. @p str must be of size at
|
||||
* most @p length. It is slightly faster than eina_binbuf_append() as
|
||||
* it does not compute the size of @p str. It is useful when dealing
|
||||
* with strings of known size, such as eina_strngshare. If @p buf
|
||||
* with strings of known size, such as eina_stringshare. If @p buf
|
||||
* can't append it, #EINA_FALSE is returned, otherwise #EINA_TRUE is
|
||||
* returned.
|
||||
*
|
||||
|
@ -261,7 +261,7 @@ EAPI Eina_Bool eina_binbuf_append_char(Eina_Binbuf *buf, unsigned char c) EINA_A
|
|||
* This function inserts @p str to @p buf. @p str must be of size at
|
||||
* most @p length. It is slightly faster than eina_binbuf_insert() as
|
||||
* it does not compute the size of @p str. It is useful when dealing
|
||||
* with strings of known size, such as eina_strngshare. If @p buf
|
||||
* with strings of known size, such as eina_stringshare. If @p buf
|
||||
* can't insert it, #EINA_FALSE is returned, otherwise #EINA_TRUE is
|
||||
* returned.
|
||||
*
|
||||
|
|
|
@ -312,7 +312,7 @@ EAPI int eina_convert_fptoa(Eina_F32p32 fp,
|
|||
* [-]0xh.hhhhhp[+-]e
|
||||
* @endcode
|
||||
*
|
||||
* where the h are the hexadecimal cyphers of the mantissas and e the
|
||||
* where the h's are the hexadecimal cyphers of the mantissas and e the
|
||||
* exponent (a decimal number). If n is the number of cyphers after the
|
||||
* point, the returned mantissas and exponents are:
|
||||
*
|
||||
|
|
|
@ -33,7 +33,7 @@
|
|||
* eina_counter_free().
|
||||
*
|
||||
* To time a part of a code, call eina_counter_start() just before it,
|
||||
* and eina_counter_stop() just after it. Each time you start to time
|
||||
* and eina_counter_stop() just after it. Each time you start timing
|
||||
* a code, a clock is added to a list. You can give the number of that
|
||||
* clock with the second argument of eina_counter_stop(). To send all
|
||||
* the registered clocks to a stream (like stdout, for a file), use
|
||||
|
@ -121,7 +121,7 @@ typedef struct _Eina_Counter Eina_Counter;
|
|||
* @param[in] name The name of the counter
|
||||
* @return A newly allocated counter
|
||||
*
|
||||
* @note Whe the new counter is not needed anymore, use eina_counter_free() to
|
||||
* @note When the new counter is not needed anymore, use eina_counter_free() to
|
||||
* free the allocated memory.
|
||||
*/
|
||||
EAPI Eina_Counter *eina_counter_new(const char *name) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
|
||||
|
@ -145,8 +145,8 @@ EAPI void eina_counter_free(Eina_Counter *counter) EINA_ARG_NONNULL(1);
|
|||
*
|
||||
* @param[in] counter The counter
|
||||
*
|
||||
* @note This function adds the clock associated to @p counter in a list. If
|
||||
* the memory needed by that clock can not be allocated, the function
|
||||
* @note This function adds the clock associated with @p counter in a list. If
|
||||
* the memory needed by that clock cannot be allocated, the function
|
||||
* returns and nothing is done.
|
||||
*
|
||||
* @note To stop the timing, eina_counter_stop() must be called with the
|
||||
|
|
|
@ -29,11 +29,11 @@
|
|||
/**
|
||||
* @defgroup Eina_Cow_Group Copy On Write
|
||||
*
|
||||
* @brief These functions provide some helper for a pseudo Copy On Write mechanism.
|
||||
* @brief These functions provide some helper for a pseudo Copy-On-Write mechanism.
|
||||
*
|
||||
* Eina_Cow will return const memory pointer to some default value that you will
|
||||
* Eina_Cow will return a const memory pointer to some default value that you will
|
||||
* be able to change only by requesting a writable pointer. Later on a garbage collector
|
||||
* can come online and try to merge back some of those pointer.
|
||||
* can come online and try to merge back some of those pointers.
|
||||
*
|
||||
* @since 1.8.0
|
||||
*
|
||||
|
@ -54,7 +54,7 @@ typedef void Eina_Cow_Data;
|
|||
/**
|
||||
* @brief Instantiates a new Eina_Cow pool.
|
||||
*
|
||||
* @param name The name of this pool, used for debug.
|
||||
* @param name The name of this pool, used for debugging.
|
||||
* @param struct_size The size of the object from this pool.
|
||||
* @param step How many objects to allocate when the pool gets empty.
|
||||
* @param default_value The default value returned by this pool.
|
||||
|
@ -89,7 +89,7 @@ EAPI void eina_cow_free(Eina_Cow *cow, const Eina_Cow_Data **data);
|
|||
|
||||
/**
|
||||
* @brief Gets a writeable pointer from a const pointer.
|
||||
* @param cow The pool the pointer come from.
|
||||
* @param cow The pool the pointer came from.
|
||||
* @param src The pointer you want to write to.
|
||||
*
|
||||
* NOTE: this function is not thread safe, be careful.
|
||||
|
@ -98,7 +98,7 @@ EAPI void *eina_cow_write(Eina_Cow *cow,
|
|||
const Eina_Cow_Data * const *src) EINA_WARN_UNUSED_RESULT;
|
||||
/**
|
||||
* @brief Sets back a pointer into read only.
|
||||
* @param cow The pool the pointer come from.
|
||||
* @param cow The pool the pointer came from.
|
||||
* @param dst The read only version of the pointer.
|
||||
* @param data The pointer to which data was written to.
|
||||
* @param needed_gc Does this pool need to be garbage collected?
|
||||
|
@ -111,7 +111,7 @@ EAPI void eina_cow_done(Eina_Cow *cow,
|
|||
Eina_Bool needed_gc);
|
||||
/**
|
||||
* @brief Makes the destination contain the same thing as the source pointer.
|
||||
* @param cow The pool the pointers come from.
|
||||
* @param cow The pool the pointers came from.
|
||||
* @param dst The destination to update.
|
||||
* @param src The source of information to copy.
|
||||
*/
|
||||
|
@ -126,20 +126,20 @@ EAPI void eina_cow_memcpy(Eina_Cow *cow,
|
|||
*
|
||||
* There is no guaranty in the time it will require, but should remain low.
|
||||
* It does run a hash function on all possible common structures trying to
|
||||
* find the one that match and merge them into one pointer.
|
||||
* find the one that matches and merge them into one pointer.
|
||||
*/
|
||||
EAPI Eina_Bool eina_cow_gc(Eina_Cow *cow);
|
||||
|
||||
/**
|
||||
* @def EINA_COW_WRITE_BEGIN
|
||||
* @brief Definition for the macro to setup a writeable pointer from a const one.
|
||||
* @param Cow The Eina_Cow where the const pointer come from.
|
||||
* @param Cow The Eina_Cow where the const pointer came from.
|
||||
* @param Read The const pointer to get a writable handler from.
|
||||
* @param Write_Type The type of the pointer you want to write to.
|
||||
* @param Write The name of the variable where to put the writeable pointer to.
|
||||
* @since 1.8.0
|
||||
*
|
||||
* Be careful this macro opens a C scope that is expected to be closed by
|
||||
* Be careful: this macro opens a C scope that is expected to be closed by
|
||||
* EINA_COW_WRITE_END().
|
||||
*/
|
||||
#define EINA_COW_WRITE_BEGIN(Cow, Read, Write_Type, Write) \
|
||||
|
@ -152,12 +152,12 @@ EAPI Eina_Bool eina_cow_gc(Eina_Cow *cow);
|
|||
/**
|
||||
* @def EINA_COW_WRITE_END
|
||||
* @brief Definition for the macro to close the writeable pointer.
|
||||
* @param Cow The Eina_Cow where the const pointer come from.
|
||||
* @param Cow The Eina_Cow where the const pointer came from.
|
||||
* @param Read The const pointer to get a writable handler from.
|
||||
* @param Write The name of the variable where to put the writeable pointer to.
|
||||
* @since 1.8.0
|
||||
*
|
||||
* Be careful this macro close the scope opened by EINA_COW_WRITE_BEGIN().
|
||||
* Be careful: this macro close the scope opened by EINA_COW_WRITE_BEGIN().
|
||||
*/
|
||||
#define EINA_COW_WRITE_END(Cow, Read, Write) \
|
||||
eina_cow_done(Cow, ((const Eina_Cow_Data**)&(Read)), Write, \
|
||||
|
|
|
@ -216,7 +216,7 @@ EAPI Eina_Debug_Dispatch_Cb eina_debug_session_dispatch_get(Eina_Debug_Session *
|
|||
/**
|
||||
* @brief Dispatch a given packet according to its header.
|
||||
*
|
||||
* This function checks the header contained into the packet and invokes
|
||||
* This function checks the header contained in the packet and invokes
|
||||
* the correct callback according to the opcode.
|
||||
* This is the default dispatcher.
|
||||
*
|
||||
|
|
|
@ -52,14 +52,14 @@ struct _Eina_Evlog_Buf
|
|||
unsigned char *buf; // current buffer we fill with event logs
|
||||
unsigned int size; // the max size of the evlog buffer
|
||||
unsigned int top; // the current top byte for a new evlog item
|
||||
unsigned int overflow; // how many times this buffer has overflown
|
||||
unsigned int overflow; // how many times this buffer has overflowed
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief Logs an event in our event log for profiling data.
|
||||
*
|
||||
* Log some interesting event inside of EFL, eg a wakeup (and why etc.).
|
||||
* The @p event string must alwasy be provided and be of the form:
|
||||
* The @p event string must always be provided and be of the form:
|
||||
*
|
||||
* "+eventname"
|
||||
* "-eventname"
|
||||
|
@ -72,12 +72,12 @@ struct _Eina_Evlog_Buf
|
|||
* events logged are really children of this event). The "-" char means an
|
||||
* event is ending and so all child events SHOULD have ended by now. A "!"
|
||||
* character means the event is a one-off with no beginning or end. A"*"
|
||||
* Means this is special metadata and the defail field may need special
|
||||
* parsing based on the eventname, so ignroe unless known. A ">"
|
||||
* means this is special metadata and the detail field may need special
|
||||
* parsing based on the eventname, so ignore unless known. A ">"
|
||||
* character means we begin this "state" of the process (these are separate
|
||||
* to "+" and "-" events and don't nest - arenot related to a thread or
|
||||
* to "+" and "-" events and don't nest - are not related to a thread or
|
||||
* any other event, but just a state). "<" Ends the given state given by
|
||||
* the "eventname" spart of the string. Any string following this initial
|
||||
* the "eventname" part of the string. Any string following this initial
|
||||
* character is the event or state name (and must be provided in the exact
|
||||
* same string at both "+", "<" and "-", ">" events). This is what will be
|
||||
* displayed in a debugger (and may be a well known string thus given a nice
|
||||
|
@ -89,11 +89,11 @@ struct _Eina_Evlog_Buf
|
|||
* The @p object is optional, and if not used, pass in NULL. If it is used,
|
||||
* it can be a pointer to anything. It is intended simply to be of use to
|
||||
* indicate an event happens on object A vs object B. What this points to
|
||||
* is irrelevant as the pointer is never de-references or used other than
|
||||
* is irrelevant as the pointer is never de-referenced or used other than
|
||||
* as a label to differentiate an event on 2 different objects.
|
||||
*
|
||||
* The @p srctime parameter is 0.0 if not used, or if used, contains a
|
||||
* timepoint for an event that triggered this one. For example, if a device
|
||||
* timepoint for an event that triggered this once. For example, if a device
|
||||
* or hardware interrupt causes this event, that device may provide a
|
||||
* timestamp/timepoint as part of the device information to indicate the
|
||||
* exact time the hardware interrupt happened. This can be useful to have
|
||||
|
|
|
@ -34,7 +34,7 @@
|
|||
* @page eina_file_example_01_page
|
||||
* @dontinclude eina_file_01.c
|
||||
*
|
||||
* To include brevity, variable declarations and initialization is omitted
|
||||
* For brevity, variable declarations and initialization are omitted
|
||||
* from this page, however the full source code can be seen @ref
|
||||
* eina_file_example_01 "here".
|
||||
*
|
||||
|
@ -512,7 +512,7 @@ EAPI Eina_File *
|
|||
eina_file_virtualize(const char *virtual_name, const void *data, unsigned long long length, Eina_Bool copy) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
|
||||
|
||||
/**
|
||||
* @brief Tells if a file is a real file or only exist in memory.
|
||||
* @brief Tells if a file is a real file or only exists in memory.
|
||||
*
|
||||
* @param file The file to test
|
||||
* @return #EINA_TRUE if the file is a virtual file
|
||||
|
|
|
@ -139,7 +139,7 @@ struct _Eina_Lines_Iterator
|
|||
const char *map; /**< A pointer to the head of the file that has been mapped with mmap(2). */
|
||||
const char *end; /**< A pointer to the end of the file that has been mapped with mmap(2). */
|
||||
|
||||
int boundary; /**< Curretnly hard coded to 4096. */
|
||||
int boundary; /**< Currently hard coded to 4096. */
|
||||
|
||||
Eina_File_Line current; /**< The current line */
|
||||
};
|
||||
|
@ -176,7 +176,7 @@ struct _Eina_Lines_Iterator
|
|||
|
||||
/**
|
||||
* @brief Determines if a path is relative or absolute.
|
||||
* The implementation simply chekcs if the fist char in the path is '/'. If it
|
||||
* The implementation simply chekcs if the first char in the path is '/'. If it
|
||||
* is not, the path is considered relative.
|
||||
*
|
||||
* @param path The path to check.
|
||||
|
@ -300,7 +300,7 @@ void eina_file_virtual_map_free(Eina_File *file, void *map);
|
|||
* @warning This function is not yet implemented. At present it ony returns
|
||||
* @code sizeof (unsigned long int) * 2 @endcode
|
||||
*
|
||||
* @param key The key for which length will be calcualted.
|
||||
* @param key The key for which length will be calculated.
|
||||
*
|
||||
* @return The length of the key.
|
||||
*
|
||||
|
|
|
@ -25,7 +25,7 @@
|
|||
* it to 0 to force the free queue to work and delay freeing of items.
|
||||
* Note that you can override this by setting count or mem max by
|
||||
* eina_freeq_count_max_set() or eina_freeq_mem_max_set() which will
|
||||
* disable bypass for that specific free queue. once bypass is disabled
|
||||
* disable bypass for that specific free queue. Once bypass is disabled
|
||||
* it cannot be re-enabled.
|
||||
*
|
||||
* EINA_FREEQ_FILL_MAX=N
|
||||
|
@ -50,7 +50,7 @@
|
|||
*
|
||||
* EINA_FREEQ_FILL=N
|
||||
*
|
||||
* This sets the buyte value to write to every byte of an allocation that
|
||||
* This sets the byte value to write to every byte of an allocation that
|
||||
* is added to the free queue when it is added to mark the data as invalid.
|
||||
* The default value is 0x55 (85). Memory is only filled if the size of
|
||||
* the allocation is less than the max that you can adjust with
|
||||
|
|
Loading…
Reference in New Issue