--- /dev/null
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">\r
+<html>\r
+<head>\r
+<link rel="stylesheet" href="../robodoc.css" type="text/css">\r
+<title>./inc_doc/complib/cl_async_proc_h.html</title>\r
+<!-- Source: ./inc/complib/cl_async_proc.h -->\r
+<!-- Generated with ROBODoc Version 4.99.22 (Mar 6 2006) -->\r
+</head>\r
+<body bgcolor="#FFFFFF">\r
+<a name="robo_top_of_doc">Generated from ./inc/complib/cl_async_proc.h</a> with <a href="http://sourceforge.net/projects/robodoc/">ROBODoc</a> v4.99.22 on Sun Apr 16 2006 17:39:25\r
+<br />\r
+<hr />\r
+\r
+<h2><a name="robo6">[Modules]<a name="Component20Library2fAsynchronous20Processor">\r
+Component Library/Asynchronous Processor</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_modules.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> Asynchronous Processor\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The asynchronous processor provides threads for executing queued callbacks.\r
+\r
+ The threads in the asynchronous processor wait for callbacks to be queued.\r
+\r
+ The asynchronous processor functions operate on a <a href="#robo271">cl_async_proc_t</a> structure\r
+ which should be treated as opaque and manipulated only through the provided\r
+ functions.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Structures:\r
+ <a href="#robo271">cl_async_proc_t</a>, <a href="#robo269">cl_async_proc_item_t</a>\r
+\r
+ Initialization:\r
+ <a href="#robo266">cl_async_proc_construct</a>, <a href="#robo268">cl_async_proc_init</a>, <a href="#robo267">cl_async_proc_destroy</a>\r
+\r
+ Manipulation:\r
+ <a href="#robo270">cl_async_proc_queue</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo266">[Functions]<a name="Component20Library3a20Asynchronous20Processor2fcl5fasync5fproc5fconstruct">\r
+Component Library: Asynchronous Processor/cl_async_proc_construct</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_async_proc_construct</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_async_proc_construct</strong> function initializes the state of a\r
+ thread pool.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT void CL_API\r
+<strong>cl_async_proc_construct</strong>(\r
+ IN <a href="#robo271">cl_async_proc_t</a>* const p_async_proc );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_async_proc\r
+ [in] Pointer to an asynchronous processor structure.\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> This function does not return a value.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> Allows calling <a href="#robo267">cl_async_proc_destroy</a> without first calling\r
+ <a href="#robo268">cl_async_proc_init</a>.\r
+\r
+ Calling <strong>cl_async_proc_construct</strong> is a prerequisite to calling any other\r
+ thread pool function except <a href="#robo268">cl_async_proc_init</a>.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Asynchronous Processor, <a href="#robo268">cl_async_proc_init</a>, <a href="#robo267">cl_async_proc_destroy</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo267">[Functions]<a name="Component20Library3a20Asynchronous20Processor2fcl5fasync5fproc5fdestroy">\r
+Component Library: Asynchronous Processor/cl_async_proc_destroy</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_async_proc_destroy</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_async_proc_destroy</strong> function performs any necessary cleanup\r
+ for a thread pool.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT void CL_API\r
+<strong>cl_async_proc_destroy</strong>(\r
+ IN <a href="#robo271">cl_async_proc_t</a>* const p_async_proc );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_async_proc\r
+ [in] Pointer to an asynchronous processor structure to destroy.\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> This function does not return a value.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> This function blocks until all threads exit, and must therefore not\r
+ be called from any of the asynchronous processor's threads. Because of\r
+ its blocking nature, callers of <strong>cl_async_proc_destroy</strong> must ensure that\r
+ entering a wait state is valid from the calling thread context.\r
+\r
+ This function should only be called after a call to\r
+ <a href="#robo266">cl_async_proc_construct</a> or <a href="#robo268">cl_async_proc_init</a>.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Asynchronous Processor, <a href="#robo266">cl_async_proc_construct</a>, <a href="#robo268">cl_async_proc_init</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo268">[Functions]<a name="Component20Library3a20Asynchronous20Processor2fcl5fasync5fproc5finit">\r
+Component Library: Asynchronous Processor/cl_async_proc_init</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_async_proc_init</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_async_proc_init</strong> function initialized an asynchronous processor\r
+ for use.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT <a href="./cl_types_h.html#robo304">cl_status_t</a> CL_API\r
+<strong>cl_async_proc_init</strong>(\r
+ IN <a href="#robo271">cl_async_proc_t</a>* const p_async_proc,\r
+ IN const uint32_t thread_count,\r
+ IN const char* const name );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_async_proc\r
+ [in] Pointer to an asynchronous processor structure to initialize.\r
+\r
+ thread_count\r
+ [in] Number of threads to be managed by the asynchronous processor.\r
+\r
+ name\r
+ [in] Name to associate with the threads. The name may be up to 16\r
+ characters, including a terminating null character. All threads\r
+ created in the asynchronous processor have the same name.\r
+\r
+ RETURN VALUES\r
+ CL_SUCCESS if the asynchronous processor creation succeeded.\r
+\r
+ CL_INSUFFICIENT_MEMORY if there was not enough memory to inititalize\r
+ the asynchronous processor.\r
+\r
+ CL_ERROR if the threads could not be created.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> <strong>cl_async_proc_init</strong> creates and starts the specified number of threads.\r
+ If thread_count is zero, the asynchronous processor creates as many\r
+ threads as there are processors in the system.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Asynchronous Processor, <a href="#robo266">cl_async_proc_construct</a>, <a href="#robo267">cl_async_proc_destroy</a>,\r
+ <a href="#robo270">cl_async_proc_queue</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo269">[Structures]<a name="Component20Library3a20Asynchronous20Processor2fcl5fasync5fproc5fitem5ft">\r
+Component Library: Asynchronous Processor/cl_async_proc_item_t</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_strutures.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_async_proc_item_t</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> Asynchronous processor item structure passed to the <a href="#robo270">cl_async_proc_queue</a>\r
+ function to queue a callback for execution.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>typedef struct _cl_async_proc_item\r
+{\r
+ <a href="./cl_qcomppool_h.html#robo542">cl_pool_item_t</a> pool_item;\r
+ <a href="#robo272">cl_pfn_async_proc_cb_t</a> pfn_callback;\r
+\r
+} <strong>cl_async_proc_item_t</strong>;\r
+</pre>\r
+</span><p><strong>FIELDS</strong></p>\r
+<span class="FIELDS"><pre> pool_item\r
+ <a href="./cl_pool_h.html#robo24">Pool</a> item for queuing the item to be invoked by the asynchronous\r
+ processor's threads. This field is defined as a pool item to\r
+ allow items to be managed by a pool.\r
+\r
+ pfn_callback\r
+ Pointer to a callback function to invoke when the item is dequeued.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Asynchronous Processor, <a href="#robo270">cl_async_proc_queue</a>, <a href="#robo272">cl_pfn_async_proc_cb_t</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo270">[Functions]<a name="Component20Library3a20Asynchronous20Processor2fcl5fasync5fproc5fqueue">\r
+Component Library: Asynchronous Processor/cl_async_proc_queue</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_async_proc_queue</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_async_proc_queue</strong> function queues a callback to an asynchronous\r
+ processor.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT void CL_API\r
+<strong>cl_async_proc_queue</strong>(\r
+ IN <a href="#robo271">cl_async_proc_t</a>* const p_async_proc,\r
+ IN <a href="#robo269">cl_async_proc_item_t</a>* const p_item );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_async_proc\r
+ [in] Pointer to an asynchronous processor structure to initialize.\r
+\r
+ p_item\r
+ [in] Pointer to an asynchronous processor item to queue for execution.\r
+ The callback and context fields of the item must be valid.\r
+\r
+ RETURN VALUES\r
+ This function does not return a value.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Asynchronous Processor, <a href="#robo268">cl_async_proc_init</a>, <a href="#robo272">cl_pfn_async_proc_cb_t</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo271">[Structures]<a name="Component20Library3a20Asynchronous20Processor2fcl5fasync5fproc5ft">\r
+Component Library: Asynchronous Processor/cl_async_proc_t</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_strutures.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_async_proc_t</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> Asynchronous processor structure.\r
+\r
+ The <strong>cl_async_proc_t</strong> structure should be treated as opaque, and should be\r
+ manipulated only through the provided functions.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>typedef struct _cl_async_proc\r
+{\r
+ <a href="./cl_threadpool_h.html#robo662">cl_thread_pool_t</a> thread_pool;\r
+ <a href="./cl_qlist_h.html#robo584">cl_qlist_t</a> item_queue;\r
+ cl_spinlock_t lock;\r
+ cl_state_t state;\r
+\r
+} <strong>cl_async_proc_t</strong>;\r
+</pre>\r
+</span><p><strong>FIELDS</strong></p>\r
+<span class="FIELDS"><pre> item_pool\r
+ <a href="./cl_pool_h.html#robo24">Pool</a> of items storing the callback function and contexts to be invoked\r
+ by the asynchronous processor's threads.\r
+\r
+ thread_pool\r
+ Thread pool that will invoke the callbacks.\r
+\r
+ item_queue\r
+ Queue of items that the threads should process.\r
+\r
+ lock\r
+ Lock used to synchronize access to the item pool and queue.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Asynchronous Processor\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo272">[Definitions]<a name="Component20Library3a20Asynchronous20Processor2fcl5fpfn5fasync5fproc5fcb5ft">\r
+Component Library: Asynchronous Processor/cl_pfn_async_proc_cb_t</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_definitions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_pfn_async_proc_cb_t</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_pfn_async_proc_cb_t</strong> function type defines the prototype for\r
+ callbacks queued to and invoked by the asynchronous processor.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>typedef void\r
+(CL_API *<strong>cl_pfn_async_proc_cb_t</strong>)(\r
+ IN struct _cl_async_proc_item *p_item );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_item\r
+ Pointer to the <a href="#robo269">cl_async_proc_item_t</a> structure that was queued in\r
+ a call to <a href="#robo270">cl_async_proc_queue</a>.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> This function type is provided as function prototype reference for the\r
+ function provided by users as a parameter to the <a href="#robo270">cl_async_proc_queue</a>\r
+ function.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Asynchronous Processor, <a href="#robo269">cl_async_proc_item_t</a>\r
+</pre>\r
+</span>\r
+</body>\r
+</html>\r
--- /dev/null
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">\r
+<html>\r
+<head>\r
+<link rel="stylesheet" href="../robodoc.css" type="text/css">\r
+<title>./inc_doc/complib/cl_atomic_h.html</title>\r
+<!-- Source: ./inc/complib/cl_atomic.h -->\r
+<!-- Generated with ROBODoc Version 4.99.22 (Mar 6 2006) -->\r
+</head>\r
+<body bgcolor="#FFFFFF">\r
+<a name="robo_top_of_doc">Generated from ./inc/complib/cl_atomic.h</a> with <a href="http://sourceforge.net/projects/robodoc/">ROBODoc</a> v4.99.22 on Sun Apr 16 2006 17:39:25\r
+<br />\r
+<hr />\r
+\r
+<h2><a name="robo7">[Modules]<a name="Component20Library2fAtomic20Operations">\r
+Component Library/Atomic Operations</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_modules.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> Atomic Operations\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The Atomic Operations functions allow callers to operate on\r
+ 32-bit signed integers in an atomic fashion.\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo273">[Functions]<a name="Component20Library3a20Atomic20Operations2fcl5fatomic5fadd">\r
+Component Library: Atomic Operations/cl_atomic_add</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_atomic_add</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_atomic_add</strong> function atomically adds a value to a\r
+ 32-bit signed integer and returns the resulting value.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT int32_t CL_API\r
+<strong>cl_atomic_add</strong>(\r
+ IN atomic32_t* const p_value,\r
+ IN const int32_t increment );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_value\r
+ [in] Pointer to a 32-bit integer that will be added to.\r
+\r
+ increment\r
+ [in] Value by which to increment the integer pointed to by p_value.\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> Returns the value pointed to by p_value after the addition.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> The provided increment is added to the value and the result returned in\r
+ one atomic operation.\r
+\r
+ <strong>cl_atomic_add</strong> maintains data consistency without requiring additional\r
+ synchronization mechanisms in multi-threaded environments.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Atomic Operations, <a href="#robo276">cl_atomic_inc</a>, <a href="#robo275">cl_atomic_dec</a>, <a href="#robo277">cl_atomic_sub</a>,\r
+ <a href="#robo278">cl_atomic_xchg</a>, <a href="#robo274">cl_atomic_comp_xchg</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo274">[Functions]<a name="Component20Library3a20Atomic20Operations2fcl5fatomic5fcomp5fxchg">\r
+Component Library: Atomic Operations/cl_atomic_comp_xchg</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_atomic_comp_xchg</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_atomic_comp_xchg</strong> function atomically compares a 32-bit signed\r
+ integer to a desired value, sets that integer to the\r
+ specified value if equal, and returns the initial value.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT int32_t CL_API\r
+<strong>cl_atomic_comp_xchg</strong>(\r
+ IN atomic32_t* const p_value,\r
+ IN const int32_t compare,\r
+ IN const int32_t new_value );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_value\r
+ [in] Pointer to a 32-bit integer to exchange with new_value.\r
+\r
+ compare\r
+ [in] Value to compare to the value pointed to by p_value.\r
+\r
+ new_value\r
+ [in] Value to assign if the value pointed to by p_value is equal to\r
+ the value specified by the compare parameter.\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> Returns the initial value of the variable pointed to by p_value.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> The value pointed to by p_value is compared to the value specified by the\r
+ compare parameter. If the two values are equal, the p_value variable is\r
+ set to new_value. The initial value pointed to by p_value is returned.\r
+\r
+ <strong>cl_atomic_comp_xchg</strong> maintains data consistency without requiring additional\r
+ synchronization mechanisms in multi-threaded environments.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Atomic Operations, <a href="#robo276">cl_atomic_inc</a>, <a href="#robo275">cl_atomic_dec</a>, <a href="#robo273">cl_atomic_add</a>,\r
+ <a href="#robo277">cl_atomic_sub</a>, <a href="#robo278">cl_atomic_xchg</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo275">[Functions]<a name="Component20Library3a20Atomic20Operations2fcl5fatomic5fdec">\r
+Component Library: Atomic Operations/cl_atomic_dec</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_atomic_dec</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_atomic_dec</strong> function atomically decrements a 32-bit signed\r
+ integer and returns the decremented value.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT int32_t CL_API\r
+<strong>cl_atomic_dec</strong>(\r
+ IN atomic32_t* const p_value );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_value\r
+ [in] Pointer to a 32-bit integer to decrement.\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> Returns the decremented value pointed to by p_value.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> The provided value is decremented and its value returned in one atomic\r
+ operation.\r
+\r
+ <strong>cl_atomic_dec</strong> maintains data consistency without requiring additional\r
+ synchronization mechanisms in multi-threaded environments.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Atomic Operations, <a href="#robo276">cl_atomic_inc</a>, <a href="#robo273">cl_atomic_add</a>, <a href="#robo277">cl_atomic_sub</a>,\r
+ <a href="#robo278">cl_atomic_xchg</a>, <a href="#robo274">cl_atomic_comp_xchg</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo276">[Functions]<a name="Component20Library3a20Atomic20Operations2fcl5fatomic5finc">\r
+Component Library: Atomic Operations/cl_atomic_inc</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_atomic_inc</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_atomic_inc</strong> function atomically increments a 32-bit signed\r
+ integer and returns the incremented value.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT int32_t CL_API\r
+<strong>cl_atomic_inc</strong>(\r
+ IN atomic32_t* const p_value );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_value\r
+ [in] Pointer to a 32-bit integer to increment.\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> Returns the incremented value pointed to by p_value.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> The provided value is incremented and its value returned in one atomic\r
+ operation.\r
+\r
+ <strong>cl_atomic_inc</strong> maintains data consistency without requiring additional\r
+ synchronization mechanisms in multi-threaded environments.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Atomic Operations, <a href="#robo275">cl_atomic_dec</a>, <a href="#robo273">cl_atomic_add</a>, <a href="#robo277">cl_atomic_sub</a>,\r
+ <a href="#robo278">cl_atomic_xchg</a>, <a href="#robo274">cl_atomic_comp_xchg</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo277">[Functions]<a name="Component20Library3a20Atomic20Operations2fcl5fatomic5fsub">\r
+Component Library: Atomic Operations/cl_atomic_sub</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_atomic_sub</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_atomic_sub</strong> function atomically subtracts a value from a\r
+ 32-bit signed integer and returns the resulting value.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT int32_t CL_API\r
+<strong>cl_atomic_sub</strong>(\r
+ IN atomic32_t* const p_value,\r
+ IN const int32_t decrement );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_value\r
+ [in] Pointer to a 32-bit integer that will be subtracted from.\r
+\r
+ decrement\r
+ [in] Value by which to decrement the integer pointed to by p_value.\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> Returns the value pointed to by p_value after the subtraction.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> The provided decrement is subtracted from the value and the result\r
+ returned in one atomic operation.\r
+\r
+ <strong>cl_atomic_sub</strong> maintains data consistency without requiring additional\r
+ synchronization mechanisms in multi-threaded environments.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Atomic Operations, <a href="#robo276">cl_atomic_inc</a>, <a href="#robo275">cl_atomic_dec</a>, <a href="#robo273">cl_atomic_add</a>,\r
+ <a href="#robo278">cl_atomic_xchg</a>, <a href="#robo274">cl_atomic_comp_xchg</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo278">[Functions]<a name="Component20Library3a20Atomic20Operations2fcl5fatomic5fxchg">\r
+Component Library: Atomic Operations/cl_atomic_xchg</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_atomic_xchg</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_atomic_xchg</strong> function atomically sets a value of a\r
+ 32-bit signed integer and returns the initial value.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT int32_t CL_API\r
+<strong>cl_atomic_xchg</strong>(\r
+ IN atomic32_t* const p_value,\r
+ IN const int32_t new_value );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_value\r
+ [in] Pointer to a 32-bit integer to exchange with new_value.\r
+\r
+ new_value\r
+ [in] Value to assign.\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> Returns the initial value pointed to by p_value.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> The provided value is exchanged with new_value and its initial value\r
+ returned in one atomic operation.\r
+\r
+ <strong>cl_atomic_xchg</strong> maintains data consistency without requiring additional\r
+ synchronization mechanisms in multi-threaded environments.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Atomic Operations, <a href="#robo276">cl_atomic_inc</a>, <a href="#robo275">cl_atomic_dec</a>, <a href="#robo273">cl_atomic_add</a>,\r
+ <a href="#robo277">cl_atomic_sub</a>, <a href="#robo274">cl_atomic_comp_xchg</a>\r
+</pre>\r
+</span>\r
+</body>\r
+</html>\r
--- /dev/null
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">\r
+<html>\r
+<head>\r
+<link rel="stylesheet" href="../robodoc.css" type="text/css">\r
+<title>./inc_doc/complib/cl_byteswap_h.html</title>\r
+<!-- Source: ./inc/complib/cl_byteswap.h -->\r
+<!-- Generated with ROBODoc Version 4.99.22 (Mar 6 2006) -->\r
+</head>\r
+<body bgcolor="#FFFFFF">\r
+<a name="robo_top_of_doc">Generated from ./inc/complib/cl_byteswap.h</a> with <a href="http://sourceforge.net/projects/robodoc/">ROBODoc</a> v4.99.22 on Sun Apr 16 2006 17:39:25\r
+<br />\r
+<hr />\r
+\r
+<h2><a name="robo8">[Modules]<a name="Component20Library2fByte20Swapping">\r
+Component Library/Byte Swapping</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_modules.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> Byte Swapping\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The byte swapping functions and macros allow swapping bytes from network\r
+ byte order to host byte order.\r
+\r
+ All data transmitted between systems should be in network byte order.\r
+ In order to utilize such data, it must be converted to host byte order\r
+ before use.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Functions:\r
+ <a href="#robo287">cl_ntoh16</a>, <a href="#robo280">cl_hton16</a>, <a href="#robo288">cl_ntoh32</a>, <a href="#robo281">cl_hton32</a>, <a href="#robo291">cl_ntoh64</a>, <a href="#robo284">cl_hton64</a>,\r
+ <a href="#robo285">cl_ntoh</a>\r
+\r
+ Macros:\r
+ <a href="#robo286">CL_NTOH16</a>, <a href="#robo279">CL_HTON16</a>, <a href="#robo289">CL_NTOH32</a>, <a href="#robo282">CL_HTON32</a>, <a href="#robo290">CL_NTOH64</a>, <a href="#robo283">CL_HTON64</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo279">[Definitions]<a name="Component20Library3a20Byte20Swapping2fCL5fHTON16">\r
+Component Library: Byte Swapping/CL_HTON16</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_definitions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>CL_HTON16</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>CL_HTON16</strong> macro converts a 16-bit value from host byte order to\r
+ network byte order. The <strong>CL_HTON16</strong> macro will cause constant values to be\r
+ swapped by the pre-processor. For variables, <strong>CL_HTON16</strong> is less efficient\r
+ than the <a href="#robo280">cl_hton16</a> function.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>* <strong>CL_HTON16</strong>( val );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> val\r
+ [in] 16-bit value to swap from host byte order to network byte order.\r
+</pre>\r
+</span><p><strong>RESULT</strong></p>\r
+<span class="RESULT"><pre> Value of val converted to network byte order.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> This macro is analogous to <a href="#robo286">CL_NTOH16</a>.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Byte Swapping, <a href="#robo286">CL_NTOH16</a>, <a href="#robo282">CL_HTON32</a>, <a href="#robo283">CL_HTON64</a>,\r
+ <a href="#robo280">cl_hton16</a>, <a href="#robo281">cl_hton32</a>, <a href="#robo284">cl_hton64</a>, <a href="#robo285">cl_ntoh</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo280">[Functions]<a name="Component20Library3a20Byte20Swapping2fcl5fhton16">\r
+Component Library: Byte Swapping/cl_hton16</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_hton16</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_hton16</strong> function converts a 16-bit value from host byte order to\r
+ network byte order.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>* uint16_t\r
+* <strong>cl_hton16</strong>(\r
+* IN const uint16_t val );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> val\r
+ [in] Value to swap from host byte order to network byte order .\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> Value of val converted to network byte order.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> This function is analogous to <a href="#robo287">cl_ntoh16</a>.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Byte Swapping, <a href="#robo287">cl_ntoh16</a>, <a href="#robo281">cl_hton32</a>, <a href="#robo284">cl_hton64</a>, <a href="#robo285">cl_ntoh</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo282">[Definitions]<a name="Component20Library3a20Byte20Swapping2fCL5fHTON32">\r
+Component Library: Byte Swapping/CL_HTON32</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_definitions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>CL_HTON32</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>CL_HTON32</strong> macro converts a 32-bit value from host byte order to\r
+ network byte order. The <strong>CL_HTON32</strong> macro will cause constant values to be\r
+ swapped by the pre-processor. For variables, <strong>CL_HTON32</strong> is less efficient\r
+ than the <a href="#robo281">cl_hton32</a> function.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>* <strong>CL_HTON32</strong>( val );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> val\r
+ [in] 32-bit value to swap from host byte order to network byte order.\r
+</pre>\r
+</span><p><strong>RESULT</strong></p>\r
+<span class="RESULT"><pre> Value of val converted to network byte order.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> This macro is analogous to <a href="#robo289">CL_NTOH32</a>.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Byte Swapping, <a href="#robo289">CL_NTOH32</a>, <a href="#robo279">CL_HTON16</a>, <a href="#robo283">CL_HTON64</a>,\r
+ <a href="#robo280">cl_hton16</a>, <a href="#robo281">cl_hton32</a>, <a href="#robo284">cl_hton64</a>, <a href="#robo285">cl_ntoh</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo281">[Functions]<a name="Component20Library3a20Byte20Swapping2fcl5fhton32">\r
+Component Library: Byte Swapping/cl_hton32</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_hton32</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_hton32</strong> function converts a 32-bit value from host byte order to\r
+ network byte order.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>* uint32_t\r
+* <strong>cl_hton32</strong>(\r
+* IN const uint32_t val );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> val\r
+ [in] Value to swap from host byte order to network byte order .\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> Value of val converted to network byte order.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> This function is analogous to <a href="#robo288">cl_ntoh32</a>.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Byte Swapping, <a href="#robo288">cl_ntoh32</a>, <a href="#robo280">cl_hton16</a>, <a href="#robo284">cl_hton64</a>, <a href="#robo285">cl_ntoh</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo283">[Definitions]<a name="Component20Library3a20Byte20Swapping2fCL5fHTON64">\r
+Component Library: Byte Swapping/CL_HTON64</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_definitions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>CL_HTON64</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>CL_HTON64</strong> macro converts a 64-bit value from host byte order to\r
+ network byte order. The <strong>CL_HTON64</strong> macro will cause constant values to be\r
+ swapped by the pre-processor. For variables, <strong>CL_HTON64</strong> is less efficient\r
+ than the <a href="#robo284">cl_hton64</a> function.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>* <strong>CL_HTON64</strong>( val );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> val\r
+ [in] 64-bit value to swap from host byte order to network byte order.\r
+</pre>\r
+</span><p><strong>RESULT</strong></p>\r
+<span class="RESULT"><pre> Value of val converted to network byte order.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> This macro is analogous to <a href="#robo290">CL_NTOH64</a>.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Byte Swapping, <a href="#robo290">CL_NTOH64</a>, <a href="#robo279">CL_HTON16</a>, <a href="#robo282">CL_HTON32</a>,\r
+ <a href="#robo280">cl_hton16</a>, <a href="#robo281">cl_hton32</a>, <a href="#robo284">cl_hton64</a>, <a href="#robo285">cl_ntoh</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo284">[Functions]<a name="Component20Library3a20Byte20Swapping2fcl5fhton64">\r
+Component Library: Byte Swapping/cl_hton64</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_hton64</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_hton64</strong> function converts a 64-bit value from host byte order to\r
+ network byte order.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>* uint64_t\r
+* <strong>cl_hton64</strong>(\r
+* IN const uint64_t val );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> val\r
+ [in] Value to swap from host byte order to network byte order .\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> Value of val converted to network byte order.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> This function is analogous to <a href="#robo291">cl_ntoh64</a>.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Byte Swapping, <a href="#robo291">cl_ntoh64</a>, <a href="#robo280">cl_hton16</a>, <a href="#robo281">cl_hton32</a>, <a href="#robo285">cl_ntoh</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo285">[Functions]<a name="Component20Library3a20Byte20Swapping2fcl5fntoh">\r
+Component Library: Byte Swapping/cl_ntoh</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_ntoh</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_ntoh</strong> function converts a value from network byte order to\r
+ host byte order.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_INLINE void CL_API\r
+<strong>cl_ntoh</strong>(\r
+ OUT char* const p_dest,\r
+ IN const char* const p_src,\r
+ IN const uint8_t size )\r
+{\r
+#if CPU_LE\r
+ uint8_t i;\r
+ char temp;\r
+\r
+ if( p_src == p_dest )\r
+ {\r
+ /* Swap in place if source and destination are the same. */\r
+ for( i = 0; i < size / 2; i++ )\r
+ {\r
+ temp = p_dest[i];\r
+ p_dest[i] = p_src[size - 1 - i];\r
+ p_dest[size - 1 - i] = temp;\r
+ }\r
+ }\r
+ else\r
+ {\r
+ for( i = 0; i < size; i++ )\r
+ p_dest[i] = p_src[size - 1 - i];\r
+ }\r
+#else\r
+ /*\r
+ * If the source and destination are not the same, copy the source to\r
+ * the destination.\r
+ */\r
+ if( p_src != p_dest )\r
+ <a href="./cl_memory_h.html#robo431">cl_memcpy</a>( p_dest, p_src, size );\r
+#endif\r
+}\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_dest\r
+ [in] Pointer to a byte array to contain the converted value of p_src.\r
+\r
+ p_src\r
+ [in] Pointer to a byte array to be converted from network byte\r
+ ordering.\r
+\r
+ size\r
+ [in] Number of bytes to swap.p_dest\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> This function does not return a value.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> <strong>cl_ntoh</strong> can perform in place swapping if both p_src and p_dest point to\r
+ the same buffer.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Byte Swapping, <a href="#robo287">cl_ntoh16</a>, <a href="#robo288">cl_ntoh32</a>, <a href="#robo291">cl_ntoh64</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo286">[Definitions]<a name="Component20Library3a20Byte20Swapping2fCL5fNTOH16">\r
+Component Library: Byte Swapping/CL_NTOH16</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_definitions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>CL_NTOH16</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>CL_NTOH16</strong> macro converts a 16-bit value from network byte order to\r
+ host byte order. The <strong>CL_NTOH16</strong> macro will cause constant values to be\r
+ swapped by the pre-processor. For variables, <strong>CL_NTOH16</strong> is less efficient\r
+ than the <a href="#robo287">cl_ntoh16</a> function.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>* <strong>CL_NTOH16</strong>( val );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> val\r
+ [in] 16-bit value to swap from network byte order to host byte order.\r
+</pre>\r
+</span><p><strong>RESULT</strong></p>\r
+<span class="RESULT"><pre> Value of val converted to host byte order.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> This macro is analogous to <a href="#robo279">CL_HTON16</a>.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Byte Swapping, <a href="#robo279">CL_HTON16</a>, <a href="#robo289">CL_NTOH32</a>, <a href="#robo290">CL_NTOH64</a>,\r
+ <a href="#robo287">cl_ntoh16</a>, <a href="#robo288">cl_ntoh32</a>, <a href="#robo291">cl_ntoh64</a>, <a href="#robo285">cl_ntoh</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo287">[Functions]<a name="Component20Library3a20Byte20Swapping2fcl5fntoh16">\r
+Component Library: Byte Swapping/cl_ntoh16</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_ntoh16</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_ntoh16</strong> function converts a 16-bit value from network byte order to\r
+ host byte order.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>* uint16_t\r
+* <strong>cl_ntoh16</strong>(\r
+* IN const uint16_t val );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> val\r
+ [in] Value to swap from network byte order to host byte order.\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> Value of val converted to host byte order.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> This function is analogous to <a href="#robo280">cl_hton16</a>.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Byte Swapping, <a href="#robo280">cl_hton16</a>, <a href="#robo288">cl_ntoh32</a>, <a href="#robo291">cl_ntoh64</a>, <a href="#robo285">cl_ntoh</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo288">[Functions]<a name="Component20Library3a20Byte20Swapping2fcl5fntoh32">\r
+Component Library: Byte Swapping/cl_ntoh32</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_ntoh32</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_ntoh32</strong> function converts a 32-bit value from network byte order to\r
+ host byte order.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>* uint32_t\r
+* <strong>cl_ntoh32</strong>(\r
+* IN const uint32_t val );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> val\r
+ [in] Value to swap from network byte order to host byte order.\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> Value of val converted in host byte order.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> This function is analogous to <a href="#robo281">cl_hton32</a>.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Byte Swapping, <a href="#robo281">cl_hton32</a>, <a href="#robo287">cl_ntoh16</a>, <a href="#robo291">cl_ntoh64</a>, <a href="#robo285">cl_ntoh</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo289">[Definitions]<a name="Component20Library3a20Byte20Swapping2fCL5fNTOH32">\r
+Component Library: Byte Swapping/CL_NTOH32</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_definitions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>CL_NTOH32</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>CL_NTOH32</strong> macro converts a 32-bit value from network byte order to\r
+ host byte order. The <strong>CL_NTOH32</strong> macro will cause constant values to be\r
+ swapped by the pre-processor. For variables, <strong>CL_NTOH32</strong> is less efficient\r
+ than the <a href="#robo288">cl_ntoh32</a> function.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>* <strong>CL_NTOH32</strong>( val );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> val\r
+ [in] 32-bit value to swap from network byte order to host byte order.\r
+</pre>\r
+</span><p><strong>RESULT</strong></p>\r
+<span class="RESULT"><pre> Value of val converted to host byte order.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> This macro is analogous to <a href="#robo282">CL_HTON32</a>.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Byte Swapping, <a href="#robo282">CL_HTON32</a>, <a href="#robo286">CL_NTOH16</a>, <a href="#robo290">CL_NTOH64</a>,\r
+ <a href="#robo287">cl_ntoh16</a>, <a href="#robo288">cl_ntoh32</a>, <a href="#robo291">cl_ntoh64</a>, <a href="#robo285">cl_ntoh</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo290">[Definitions]<a name="Component20Library3a20Byte20Swapping2fCL5fNTOH64">\r
+Component Library: Byte Swapping/CL_NTOH64</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_definitions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>CL_NTOH64</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>CL_NTOH64</strong> macro converts a 64-bit value from network byte order to\r
+ host byte order. The <strong>CL_NTOH64</strong> macro will cause constant values to be\r
+ swapped by the pre-processor. For variables, <strong>CL_NTOH64</strong> is less efficient\r
+ than the <a href="#robo291">cl_ntoh64</a> function.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>* <strong>CL_NTOH64</strong>( val );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> val\r
+ [in] 64-bit value to swap from network byte order to host byte order.\r
+</pre>\r
+</span><p><strong>RESULT</strong></p>\r
+<span class="RESULT"><pre> Value of val converted to host byte order.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> This macro is analogous to <a href="#robo283">CL_HTON64</a>.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Byte Swapping, <a href="#robo283">CL_HTON64</a>, <a href="#robo286">CL_NTOH16</a>, <a href="#robo289">CL_NTOH32</a>,\r
+ <a href="#robo287">cl_ntoh16</a>, <a href="#robo288">cl_ntoh32</a>, <a href="#robo291">cl_ntoh64</a>, <a href="#robo285">cl_ntoh</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo291">[Functions]<a name="Component20Library3a20Byte20Swapping2fcl5fntoh64">\r
+Component Library: Byte Swapping/cl_ntoh64</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_ntoh64</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_ntoh64</strong> function converts a 64-bit value from network byte order to\r
+ host byte order.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>* uint64_t\r
+* <strong>cl_ntoh64</strong>(\r
+* IN const uint64_t val );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> val\r
+ [in] Value to swap from network byte order to host byte order.\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> Value of val converted in host byte order.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> This function is analogous to <a href="#robo284">cl_hton64</a>.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Byte Swapping, <a href="#robo284">cl_hton64</a>, <a href="#robo287">cl_ntoh16</a>, <a href="#robo288">cl_ntoh32</a>, <a href="#robo285">cl_ntoh</a>\r
+</pre>\r
+</span>\r
+</body>\r
+</html>\r
--- /dev/null
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">\r
+<html>\r
+<head>\r
+<link rel="stylesheet" href="../robodoc.css" type="text/css">\r
+<title>./inc_doc/complib/cl_comppool_h.html</title>\r
+<!-- Source: ./inc/complib/cl_comppool.h -->\r
+<!-- Generated with ROBODoc Version 4.99.22 (Mar 6 2006) -->\r
+</head>\r
+<body bgcolor="#FFFFFF">\r
+<a name="robo_top_of_doc">Generated from ./inc/complib/cl_comppool.h</a> with <a href="http://sourceforge.net/projects/robodoc/">ROBODoc</a> v4.99.22 on Sun Apr 16 2006 17:39:25\r
+<br />\r
+<hr />\r
+\r
+<h2><a name="robo9">[Modules]<a name="Component20Library2fComposite20Pool">\r
+Component Library/Composite Pool</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_modules.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> Composite <a href="./cl_pool_h.html#robo24">Pool</a>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The Composite <a href="./cl_pool_h.html#robo24">Pool</a> provides a self-contained and self-sustaining pool of\r
+ user defined composite objects.\r
+\r
+ A composite object is an object that is composed of one or more\r
+ sub-objects, each of which needs to be treated separately for\r
+ initialization. Objects can be retrieved from the pool as long as there\r
+ is memory in the system.\r
+\r
+ To aid in object oriented design, the composite pool provides the user\r
+ the ability to specify callbacks that are invoked for each object for\r
+ construction, initialization, and destruction. Constructor and destructor\r
+ callback functions may not fail.\r
+\r
+ A composite pool does not return memory to the system as the user returns\r
+ objects to the pool. The only method of returning memory to the system is\r
+ to destroy the pool.\r
+\r
+ The composite pool functions operates on a <a href="#robo299">cl_cpool_t</a> structure which\r
+ should be treated as opaque and should be manipulated only through the\r
+ provided functions.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Structures:\r
+ <a href="#robo299">cl_cpool_t</a>\r
+\r
+ Callbacks:\r
+ <a href="#robo302">cl_pfn_cpool_init_t</a>, <a href="#robo301">cl_pfn_cpool_dtor_t</a>\r
+\r
+ Initialization/Destruction:\r
+ <a href="#robo292">cl_cpool_construct</a>, <a href="#robo297">cl_cpool_init</a>, <a href="#robo294">cl_cpool_destroy</a>\r
+\r
+ Manipulation:\r
+ <a href="#robo295">cl_cpool_get</a>, <a href="#robo298">cl_cpool_put</a>, <a href="#robo296">cl_cpool_grow</a>\r
+\r
+ Attributes:\r
+ <a href="#robo300">cl_is_cpool_inited</a>, <a href="#robo293">cl_cpool_count</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo292">[Functions]<a name="Component20Library3a20Composite20Pool2fcl5fcpool5fconstruct">\r
+Component Library: Composite Pool/cl_cpool_construct</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_cpool_construct</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_cpool_construct</strong> function constructs a composite pool.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT void CL_API\r
+<strong>cl_cpool_construct</strong>(\r
+ IN <a href="#robo299">cl_cpool_t</a>* const p_pool );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_pool\r
+ [in] Pointer to a <a href="#robo299">cl_cpool_t</a> structure whose state to initialize.\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> This function does not return a value.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> Allows calling <a href="./cl_pool_h.html#robo536">cl_pool_init</a>, <a href="#robo294">cl_cpool_destroy</a>, <a href="#robo300">cl_is_cpool_inited</a>.\r
+\r
+ Calling <strong>cl_cpool_construct</strong> is a prerequisite to calling any other\r
+ composite pool function except <a href="#robo297">cl_cpool_init</a>.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Composite <a href="./cl_pool_h.html#robo24">Pool</a>, <a href="#robo297">cl_cpool_init</a>, <a href="#robo294">cl_cpool_destroy</a>, <a href="#robo300">cl_is_cpool_inited</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo293">[Functions]<a name="Component20Library3a20Composite20Pool2fcl5fcpool5fcount">\r
+Component Library: Composite Pool/cl_cpool_count</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_cpool_count</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_cpool_count</strong> function returns the number of available objects\r
+ in a composite pool.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_INLINE size_t CL_API\r
+<strong>cl_cpool_count</strong>(\r
+ IN <a href="#robo299">cl_cpool_t</a>* const p_pool )\r
+{\r
+ CL_ASSERT( p_pool );\r
+ return( <a href="./cl_qcomppool_h.html#robo544">cl_qcpool_count</a>( &p_pool->qcpool ) );\r
+}\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_pool\r
+ [in] Pointer to a <a href="#robo299">cl_cpool_t</a> structure for which the number of\r
+ available objects is requested.\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> Returns the number of objects available in the specified\r
+ composite pool.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Composite <a href="./cl_pool_h.html#robo24">Pool</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo294">[Functions]<a name="Component20Library3a20Composite20Pool2fcl5fcpool5fdestroy">\r
+Component Library: Composite Pool/cl_cpool_destroy</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_cpool_destroy</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_cpool_destroy</strong> function destroys a composite pool.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_INLINE void CL_API\r
+<strong>cl_cpool_destroy</strong>(\r
+ IN <a href="#robo299">cl_cpool_t</a>* const p_pool )\r
+{\r
+ CL_ASSERT( p_pool );\r
+\r
+ <a href="./cl_qcomppool_h.html#robo545">cl_qcpool_destroy</a>( &p_pool->qcpool );\r
+}\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_pool\r
+ [in] Pointer to a <a href="#robo299">cl_cpool_t</a> structure to destroy.\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> This function does not return a value.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> All memory allocated for composite objects is freed. The destructor\r
+ callback, if any, will be invoked for every allocated object. Further\r
+ operations on the composite pool should not be attempted after\r
+ <strong>cl_cpool_destroy</strong> is invoked.\r
+\r
+ This function should only be called after a call to <a href="#robo292">cl_cpool_construct</a>.\r
+\r
+ In a debug build, <strong>cl_cpool_destroy</strong> asserts that all objects are in\r
+ the pool.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Composite <a href="./cl_pool_h.html#robo24">Pool</a>, <a href="#robo292">cl_cpool_construct</a>, <a href="#robo297">cl_cpool_init</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo295">[Functions]<a name="Component20Library3a20Composite20Pool2fcl5fcpool5fget">\r
+Component Library: Composite Pool/cl_cpool_get</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_cpool_get</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_cpool_get</strong> function retrieves an object from a\r
+ composite pool.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_INLINE void* CL_API\r
+<strong>cl_cpool_get</strong>(\r
+ IN <a href="#robo299">cl_cpool_t</a>* const p_pool )\r
+{\r
+ cl_pool_obj_t *p_pool_obj;\r
+\r
+ CL_ASSERT( p_pool );\r
+\r
+ p_pool_obj = (cl_pool_obj_t*)<a href="./cl_qcomppool_h.html#robo546">cl_qcpool_get</a>( &p_pool->qcpool );\r
+ if( !p_pool_obj )\r
+ return( NULL );\r
+\r
+ CL_ASSERT( p_pool_obj->list_obj.p_object );\r
+ return( (void*)p_pool_obj->list_obj.p_object );\r
+}\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_pool\r
+ [in] Pointer to a <a href="#robo299">cl_cpool_t</a> structure from which to retrieve\r
+ an object.\r
+\r
+ RETURN VALUES\r
+ Returns a pointer to the first component of a composite object.\r
+\r
+ Returns NULL if the pool is empty and can not be grown automatically.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> <strong>cl_cpool_get</strong> returns the object at the head of the pool. If the pool is\r
+ empty, it is automatically grown to accommodate this request unless the\r
+ grow_size parameter passed to the <a href="#robo297">cl_cpool_init</a> function was zero.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Composite <a href="./cl_pool_h.html#robo24">Pool</a>, cl_cpool_get_tail, <a href="#robo298">cl_cpool_put</a>, <a href="#robo296">cl_cpool_grow</a>,\r
+ <a href="#robo293">cl_cpool_count</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo296">[Functions]<a name="Component20Library3a20Composite20Pool2fcl5fcpool5fgrow">\r
+Component Library: Composite Pool/cl_cpool_grow</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_cpool_grow</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_cpool_grow</strong> function grows a composite pool by\r
+ the specified number of objects.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_INLINE <a href="./cl_types_h.html#robo304">cl_status_t</a> CL_API\r
+<strong>cl_cpool_grow</strong>(\r
+ IN <a href="#robo299">cl_cpool_t</a>* const p_pool,\r
+ IN const size_t obj_count )\r
+{\r
+ CL_ASSERT( p_pool );\r
+ return( <a href="./cl_qcomppool_h.html#robo547">cl_qcpool_grow</a>( &p_pool->qcpool, obj_count ) );\r
+}\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_pool\r
+ [in] Pointer to a <a href="#robo299">cl_cpool_t</a> structure whose capacity to grow.\r
+\r
+ obj_count\r
+ [in] Number of objects by which to grow the pool.\r
+\r
+ RETURN VALUES\r
+ CL_SUCCESS if the composite pool grew successfully.\r
+\r
+ CL_INSUFFICIENT_MEMORY if there was not enough memory to grow the\r
+ composite pool.\r
+\r
+ <a href="./cl_types_h.html#robo304">cl_status_t</a> value returned by optional initialization callback function\r
+ specified by the pfn_initializer parameter passed to the\r
+ <a href="#robo297">cl_cpool_init</a> function.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> It is not necessary to call <strong>cl_cpool_grow</strong> if the pool is\r
+ configured to grow automatically.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Composite <a href="./cl_pool_h.html#robo24">Pool</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo297">[Functions]<a name="Component20Library3a20Composite20Pool2fcl5fcpool5finit">\r
+Component Library: Composite Pool/cl_cpool_init</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_cpool_init</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_cpool_init</strong> function initializes a composite pool for use.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT <a href="./cl_types_h.html#robo304">cl_status_t</a> CL_API\r
+<strong>cl_cpool_init</strong>(\r
+ IN <a href="#robo299">cl_cpool_t</a>* const p_pool,\r
+ IN const size_t min_size,\r
+ IN const size_t max_size,\r
+ IN const size_t grow_size,\r
+ IN size_t* const component_sizes,\r
+ IN const uint32_t num_components,\r
+ IN <a href="#robo302">cl_pfn_cpool_init_t</a> pfn_initializer OPTIONAL,\r
+ IN <a href="#robo301">cl_pfn_cpool_dtor_t</a> pfn_destructor OPTIONAL,\r
+ IN const void* const context );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_pool\r
+ [in] Pointer to a <a href="#robo299">cl_cpool_t</a> structure to initialize.\r
+\r
+ min_size\r
+ [in] Minimum number of objects that the pool should support. All\r
+ necessary allocations to allow storing the minimum number of items\r
+ are performed at initialization time, and all necessary callbacks\r
+ successfully invoked.\r
+\r
+ max_size\r
+ [in] Maximum number of objects to which the pool is allowed to grow.\r
+ A value of zero specifies no maximum.\r
+\r
+ grow_size\r
+ [in] Number of objects to allocate when incrementally growing the pool.\r
+ A value of zero disables automatic growth.\r
+\r
+ component_sizes\r
+ [in] Pointer to the first entry in an array of sizes describing,\r
+ in order, the sizes of the components that make up a composite object.\r
+\r
+ num_components\r
+ [in] Number of components that make up a composite object.\r
+\r
+ pfn_initializer\r
+ [in] Initialization callback to invoke for every new object when\r
+ growing the pool. This parameter may be NULL only if the objects\r
+ stored in the composite pool consist of only one component.\r
+ See the cl_pfn_cpool_init function type declaration for details\r
+ about the callback function.\r
+\r
+ pfn_destructor\r
+ [in] Destructor callback to invoke for every object before memory for\r
+ that object is freed. This parameter is optional and may be NULL.\r
+ See the cl_pfn_cpool_dtor function type declaration for details\r
+ about the callback function.\r
+\r
+ context\r
+ [in] Value to pass to the callback functions to provide context.\r
+\r
+ RETURN VALUES\r
+ CL_SUCCESS if the composite pool was initialized successfully.\r
+\r
+ CL_INSUFFICIENT_MEMORY if there was not enough memory to initialize the\r
+ composite pool.\r
+\r
+ CL_INVALID_SETTING if a NULL constructor was provided for composite objects\r
+ consisting of more than one component. Also returns CL_INVALID_SETTING if\r
+ the maximum size is non-zero and less than the minimum size.\r
+\r
+ Other <a href="./cl_types_h.html#robo304">cl_status_t</a> value returned by optional initialization callback function\r
+ specified by the pfn_initializer parameter.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> <strong>cl_cpool_init</strong> initializes, and if necessary, grows the pool to\r
+ the capacity desired.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Composite <a href="./cl_pool_h.html#robo24">Pool</a>, <a href="#robo292">cl_cpool_construct</a>, <a href="#robo294">cl_cpool_destroy</a>,\r
+ <a href="#robo295">cl_cpool_get</a>, <a href="#robo298">cl_cpool_put</a>, <a href="#robo296">cl_cpool_grow</a>,\r
+ <a href="#robo293">cl_cpool_count</a>, cl_pfn_cpool_ctor_t, <a href="#robo302">cl_pfn_cpool_init_t</a>,\r
+ <a href="#robo301">cl_pfn_cpool_dtor_t</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo298">[Functions]<a name="Component20Library3a20Composite20Pool2fcl5fcpool5fput">\r
+Component Library: Composite Pool/cl_cpool_put</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_cpool_put</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_cpool_put</strong> function returns an object to a composite pool.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_INLINE void CL_API\r
+<strong>cl_cpool_put</strong>(\r
+ IN <a href="#robo299">cl_cpool_t</a>* const p_pool,\r
+ IN void* const p_object )\r
+{\r
+ cl_pool_obj_t *p_pool_obj;\r
+\r
+ CL_ASSERT( p_pool );\r
+ CL_ASSERT( p_object );\r
+\r
+ /* Calculate the offset to the list object representing this object. */\r
+ p_pool_obj = (cl_pool_obj_t*)\r
+ (((uint8_t*)p_object) - sizeof(cl_pool_obj_t));\r
+\r
+ /* good sanity check */\r
+ CL_ASSERT( p_pool_obj->list_obj.p_object == p_object );\r
+\r
+ <a href="./cl_qcomppool_h.html#robo549">cl_qcpool_put</a>( &p_pool->qcpool, (<a href="./cl_qcomppool_h.html#robo542">cl_pool_item_t</a>*)p_pool_obj );\r
+}\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_pool\r
+ [in] Pointer to a <a href="#robo299">cl_cpool_t</a> structure to which to return\r
+ an object.\r
+\r
+ p_object\r
+ [in] Pointer to the first component of an object to return to the pool.\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> This function does not return a value.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> <strong>cl_cpool_put</strong> places the returned object at the head of the pool.\r
+\r
+ The object specified by the p_object parameter must have been\r
+ retrieved from the pool by a previous call to <a href="#robo295">cl_cpool_get</a>.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Composite <a href="./cl_pool_h.html#robo24">Pool</a>, cl_cpool_put_tail, <a href="#robo295">cl_cpool_get</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo299">[Structures]<a name="Component20Library3a20Composite20Pool2fcl5fcpool5ft">\r
+Component Library: Composite Pool/cl_cpool_t</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_strutures.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_cpool_t</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> Composite pool structure.\r
+\r
+ The <strong>cl_cpool_t</strong> structure should be treated as opaque and should be\r
+ manipulated only through the provided functions.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>typedef struct _cl_cpool\r
+{\r
+ <a href="./cl_qcomppool_h.html#robo551">cl_qcpool_t</a> qcpool;\r
+ <a href="#robo302">cl_pfn_cpool_init_t</a> pfn_init;\r
+ <a href="#robo301">cl_pfn_cpool_dtor_t</a> pfn_dtor;\r
+ const void *context;\r
+\r
+} <strong>cl_cpool_t</strong>;\r
+</pre>\r
+</span><p><strong>FIELDS</strong></p>\r
+<span class="FIELDS"><pre> qcpool\r
+ Quick composite pool that manages all objects.\r
+\r
+ pfn_init\r
+ Pointer to the user's initializer callback, used by the pool\r
+ to translate the quick composite pool's initializer callback to\r
+ a composite pool initializer callback.\r
+\r
+ pfn_dtor\r
+ Pointer to the user's destructor callback, used by the pool\r
+ to translate the quick composite pool's destructor callback to\r
+ a composite pool destructor callback.\r
+\r
+ context\r
+ User's provided context for callback functions, used by the pool\r
+ to when invoking callbacks.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Composite <a href="./cl_pool_h.html#robo24">Pool</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo300">[Functions]<a name="Component20Library3a20Composite20Pool2fcl5fis5fcpool5finited">\r
+Component Library: Composite Pool/cl_is_cpool_inited</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_is_cpool_inited</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_is_cpool_inited</strong> function returns whether a composite pool was\r
+ successfully initialized.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_INLINE boolean_t CL_API\r
+<strong>cl_is_cpool_inited</strong>(\r
+ IN const <a href="#robo299">cl_cpool_t</a>* const p_pool )\r
+{\r
+ /* CL_ASSERT that a non-null pointer is provided. */\r
+ CL_ASSERT( p_pool );\r
+ return( <a href="./cl_qcomppool_h.html#robo539">cl_is_qcpool_inited</a>( &p_pool->qcpool ) );\r
+}\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_pool\r
+ [in] Pointer to a <a href="#robo299">cl_cpool_t</a> structure whose initialization state\r
+ to check.\r
+\r
+ RETURN VALUES\r
+ TRUE if the composite pool was initialized successfully.\r
+\r
+ FALSE otherwise.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> Allows checking the state of a composite pool to determine if invoking\r
+ member functions is appropriate.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Composite <a href="./cl_pool_h.html#robo24">Pool</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo301">[Definitions]<a name="Component20Library3a20Composite20Pool2fcl5fpfn5fcpool5fdtor5ft">\r
+Component Library: Composite Pool/cl_pfn_cpool_dtor_t</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_definitions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_pfn_cpool_dtor_t</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_pfn_cpool_dtor_t</strong> function type defines the prototype for\r
+ functions used as destructor for objects being deallocated by a\r
+ composite pool.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>typedef void\r
+(CL_API *<strong>cl_pfn_cpool_dtor_t</strong>)(\r
+ IN void* const p_object,\r
+ IN void* context );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_object\r
+ [in] Pointer to an object to destruct.\r
+\r
+ context\r
+ [in] Context provided in the call to <a href="#robo297">cl_cpool_init</a>.\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> This function does not return a value.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> This function type is provided as function prototype reference for\r
+ the function provided by the user as an optional parameter to the\r
+ <a href="#robo297">cl_cpool_init</a> function.\r
+\r
+ The destructor is invoked once per allocated object, allowing the user\r
+ to perform any necessary cleanup. Users should not attempt to deallocate\r
+ the memory for the composite object, as the composite pool manages\r
+ object allocation and deallocation.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Composite <a href="./cl_pool_h.html#robo24">Pool</a>, <a href="#robo297">cl_cpool_init</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo302">[Definitions]<a name="Component20Library3a20Composite20Pool2fcl5fpfn5fcpool5finit5ft">\r
+Component Library: Composite Pool/cl_pfn_cpool_init_t</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_definitions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_pfn_cpool_init_t</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_pfn_cpool_init_t</strong> function type defines the prototype for\r
+ functions used as initializers for objects being allocated by a\r
+ composite pool.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>typedef <a href="./cl_types_h.html#robo304">cl_status_t</a>\r
+(CL_API *<strong>cl_pfn_cpool_init_t</strong>)(\r
+ IN void** const p_comp_array,\r
+ IN const uint32_t num_components,\r
+ IN void* context );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_object\r
+ [in] Pointer to an object to initialize.\r
+\r
+ context\r
+ [in] Context provided in a call to <a href="#robo297">cl_cpool_init</a>.\r
+\r
+ RETURN VALUES\r
+ Return CL_SUCCESS to indicates that initialization of the object\r
+ was successful and that initialization of further objects may continue.\r
+\r
+ Other <a href="./cl_types_h.html#robo304">cl_status_t</a> values will be returned by <a href="#robo297">cl_cpool_init</a>\r
+ and <a href="#robo296">cl_cpool_grow</a>.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> This function type is provided as function prototype reference for\r
+ the function provided by the user as an optional parameter to the\r
+ <a href="#robo297">cl_cpool_init</a> function.\r
+\r
+ The initializer is invoked once per allocated object, allowing the user\r
+ to chain components to form a composite object and perform any necessary\r
+ initialization. Returning a status other than CL_SUCCESS aborts a grow\r
+ operation, initiated either through <a href="#robo297">cl_cpool_init</a> or <a href="#robo296">cl_cpool_grow</a>, and\r
+ causes the initiating function to fail. Any non-CL_SUCCESS status will\r
+ be returned by the function that initiated the grow operation.\r
+\r
+ All memory for the requested number of components is pre-allocated.\r
+\r
+ When later performing a <a href="#robo295">cl_cpool_get</a> call, the return value is a pointer\r
+ to the first component.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Composite <a href="./cl_pool_h.html#robo24">Pool</a>, <a href="#robo297">cl_cpool_init</a>, <a href="#robo296">cl_cpool_grow</a>\r
+</pre>\r
+</span>\r
+</body>\r
+</html>\r
--- /dev/null
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">\r
+<html>\r
+<head>\r
+<link rel="stylesheet" href="../robodoc.css" type="text/css">\r
+<title>./inc_doc/complib/cl_debug_h.html</title>\r
+<!-- Source: ./inc/complib/cl_debug.h -->\r
+<!-- Generated with ROBODoc Version 4.99.22 (Mar 6 2006) -->\r
+</head>\r
+<body bgcolor="#FFFFFF">\r
+<a name="robo_top_of_doc">Generated from ./inc/complib/cl_debug.h</a> with <a href="http://sourceforge.net/projects/robodoc/">ROBODoc</a> v4.99.22 on Sun Apr 16 2006 17:39:25\r
+<br />\r
+<hr />\r
+\r
+<h2><a name="robo10">[Modules]<a name="Component20Library2fDebug20Output">\r
+Component Library/Debug Output</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_modules.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> Debug Output\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The debug output functions and macros send debug messages to the current\r
+ debug target.\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo305">[Definitions]<a name="Component20Library3a20Debug20Output2f642dbit20Print20Format">\r
+Component Library: Debug Output/64-bit Print Format</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_definitions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> 64-bit Print Format\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The 64-bit print keywords allow users to use 64-bit values in debug or\r
+ console output.\r
+\r
+ Different platforms define 64-bit print formats differently. The 64-bit\r
+ print formats exposed by the component library are supported in all\r
+ platforms.\r
+</pre>\r
+</span><p><strong>VALUES</strong></p>\r
+<span class="VALUES"><pre> PRId64\r
+ Print a 64-bit integer in signed decimal format.\r
+ PRIx64\r
+ Print a 64-bit integer in hexadecimal format.\r
+ PRIo64\r
+ Print a 64-bit integer in octal format.\r
+ PRIu64\r
+ Print a 64-bit integer in unsigned decimal format.\r
+</pre>\r
+</span><p><strong>EXAMPLE</strong></p>\r
+<span class="EXAMPLE"><pre> uint64 MyVal = 2;\r
+ // Print a 64-bit integer in hexadecimal format.\r
+ <a href="#robo307">cl_dbg_out</a>( "MyVal: 0x%" PRIx64 "\n", MyVal );\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> Standard print flags to specify padding and precision can still be used\r
+ following the '%' sign in the string preceding the 64-bit print keyword.\r
+\r
+ The above keywords are strings and make use of compilers' string\r
+ concatenation ability.\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo306">[Functions]<a name="Component20Library3a20Debug20Output2fcl5fbreak">\r
+Component Library: Debug Output/cl_break</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_break</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_break</strong> function halts execution.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>* void\r
+* <strong>cl_break</strong>();\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> This function does not return a value.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> In a release build, <strong>cl_break</strong> has no effect.\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo307">[Functions]<a name="Component20Library3a20Debug20Output2fcl5fdbg5fout">\r
+Component Library: Debug Output/cl_dbg_out</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_dbg_out</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_dbg_out</strong> function sends a debug message to the debug target in\r
+ debug builds only.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT void\r
+<strong>cl_dbg_out</strong>(\r
+ IN const char* const debug_message,\r
+ IN ... );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> debug_message\r
+ [in] ANSI string formatted identically as for a call to the standard C\r
+ function printf.\r
+\r
+ ...\r
+ [in] Extra parameters for string formatting, as defined for the\r
+ standard C function printf.\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> This function does not return a value.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> In a release build, <strong>cl_dbg_out</strong> has no effect.\r
+\r
+ The formatting of the debug_message string is the same as for printf\r
+\r
+ <strong>cl_dbg_out</strong> sends the debug message to the current debug target.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Debug Output, <a href="#robo310">cl_msg_out</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo308">[Definitions]<a name="Component20Library3a20Debug20Output2fCL5fENTER">\r
+Component Library: Debug Output/CL_ENTER</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_definitions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>CL_ENTER</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>CL_ENTER</strong> macro marks the entrance into a function by sending a\r
+ string to the current debug target if the requested debug level matches\r
+ the current debug level.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>* <strong>CL_ENTER</strong>( DBG_LVL, CHK_LVL );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> DBG_LVL\r
+ [in] Debug level for the string to output\r
+\r
+ CHK_LVL\r
+ [in] Current debug level against which to check DBG_LVL\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> This macro does not return a value.\r
+</pre>\r
+</span><p><strong>EXAMPLE</strong></p>\r
+<span class="EXAMPLE"><pre> #define __MODULE__ "my_module"\r
+ #define MY_FUNC_DBG_LVL 1\r
+\r
+ uint32_t my_dbg_lvl = CL_DBG_ALL;\r
+\r
+ void\r
+ my_func()\r
+ {\r
+ <strong>CL_ENTER</strong>( MY_FUNC_DBG_LVL, my_dbg_lvl );\r
+ <a href="#robo309">CL_EXIT</a>( MY_FUNC_DBG_LVL, my_dbg_lvl );\r
+ }\r
+</pre>\r
+</span><p><strong>RESULT</strong></p>\r
+<span class="RESULT"><pre> my_module:my_func() [\r
+ my_module:my_func() ]\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> The function entrance notification is printed only if all bits set\r
+ in DBG_LVL are also set in CHK_LVL. CHK_LVL may have additional bits set.\r
+\r
+ If the __MODULE__ preprocessor keyword is defined, that keyword will be\r
+ prepended to the function name, separated with a colon.\r
+\r
+ In multi-processor environments where the current processor can be\r
+ determined, the zero-based number of the processor on which the output\r
+ is generated is prepended to the output.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Debug Output, Debug Levels, <a href="#robo311">CL_PRINT</a>, <a href="#robo309">CL_EXIT</a>, <a href="#robo312">CL_TRACE</a>, <a href="#robo313">CL_TRACE_EXIT</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo309">[Definitions]<a name="Component20Library3a20Debug20Output2fCL5fEXIT">\r
+Component Library: Debug Output/CL_EXIT</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_definitions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>CL_EXIT</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>CL_EXIT</strong> macro marks the exit from a function by sending a string\r
+ to the current debug target if the requested debug level matches the\r
+ current debug level.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>* <strong>CL_EXIT</strong>( DBG_LVL, CHK_LVL );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> DBG_LVL\r
+ [in] Debug level for the string to output\r
+\r
+ CHK_LVL\r
+ [in] Current debug level against which to check DBG_LVL\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> This macro does not return a value.\r
+</pre>\r
+</span><p><strong>EXAMPLE</strong></p>\r
+<span class="EXAMPLE"><pre> #define __MODULE__ "my_module"\r
+ #define MY_FUNC_DBG_LVL 1\r
+\r
+ uint32_t my_dbg_lvl = CL_DBG_ALL;\r
+\r
+ void\r
+ my_func()\r
+ {\r
+ <a href="#robo308">CL_ENTER</a>( MY_FUNC_DBG_LVL, my_dbg_lvl );\r
+ <strong>CL_EXIT</strong>( MY_FUNC_DBG_LVL, my_dbg_lvl );\r
+ }\r
+</pre>\r
+</span><p><strong>RESULT</strong></p>\r
+<span class="RESULT"><pre> my_module:my_func() [\r
+ my_module:my_func() ]\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> The exit notification is printed only if all bits set in DBG_LVL are also\r
+ set in CHK_LVL. CHK_LVL may have additional bits set.\r
+\r
+ The <strong>CL_EXIT</strong> macro must only be used after the CL_ENTRY macro as it\r
+ depends on that macro's implementation.\r
+\r
+ If the __MODULE__ preprocessor keyword is defined, that keyword will be\r
+ prepended to the function name, separated with a colon.\r
+\r
+ In multi-processor environments where the current processor can be\r
+ determined, the zero-based number of the processor on which the output\r
+ is generated is prepended to the output.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Debug Output, Debug Levels, <a href="#robo311">CL_PRINT</a>, <a href="#robo308">CL_ENTER</a>, <a href="#robo312">CL_TRACE</a>, <a href="#robo313">CL_TRACE_EXIT</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo310">[Functions]<a name="Component20Library3a20Debug20Output2fcl5fmsg5fout">\r
+Component Library: Debug Output/cl_msg_out</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_msg_out</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_msg_out</strong> function sends a debug message to the message log target.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT void\r
+<strong>cl_msg_out</strong>(\r
+ IN const char* const message,\r
+ IN ... );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> message\r
+ [in] ANSI string formatted identically as for a call to the standard C\r
+ function printf.\r
+\r
+ ...\r
+ [in] Extra parameters for string formatting, as defined for the\r
+ standard C function printf.\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> This function does not return a value.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> <strong>cl_msg_out</strong> is available in both debug and release builds.\r
+\r
+ The formatting of the message string is the same as for printf\r
+\r
+ <strong>cl_msg_out</strong> sends the message to the current message logging target.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Debug Output, <a href="#robo307">cl_dbg_out</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo311">[Definitions]<a name="Component20Library3a20Debug20Output2fCL5fPRINT">\r
+Component Library: Debug Output/CL_PRINT</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_definitions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>CL_PRINT</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>CL_PRINT</strong> macro sends a string to the current debug target if\r
+ the requested debug level matches the current debug level.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>* <strong>CL_PRINT</strong>( DBG_LVL, CHK_LVL, STRING );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> DBG_LVL\r
+ [in] Debug level for the string to output\r
+\r
+ CHK_LVL\r
+ [in] Current debug level against which to check DBG_LVL\r
+\r
+ STRING\r
+ [in] String to send to the current debug target. The string includes\r
+ parentheses in order to allow additional parameters.\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> This macro does not return a value.\r
+</pre>\r
+</span><p><strong>EXAMPLE</strong></p>\r
+<span class="EXAMPLE"><pre> #define MY_FUNC_DBG_LVL 1\r
+\r
+ uint32_t my_dbg_lvl = CL_DBG_ALL;\r
+\r
+ void\r
+ my_func()\r
+ {\r
+ <strong>CL_PRINT</strong>( MY_FUNC_DBG_LVL, my_dbg_lvl, ("Hello %s!\n", "world") );\r
+ }\r
+</pre>\r
+</span><p><strong>RESULT</strong></p>\r
+<span class="RESULT"><pre> Hello world!\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> The requested string is printed only if all bits set in DBG_LVL are also\r
+ set in CHK_LVL unless the most significant bit is set (indicating an\r
+ error), in which case the lower bits are ignored. CHK_LVL may have\r
+ additional bits set.\r
+\r
+ In multi-processor environments where the current processor can be\r
+ determined, the zero-based number of the processor on which the output\r
+ is generated is prepended to the output.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Debug Output, Debug Levels, <a href="#robo308">CL_ENTER</a>, <a href="#robo309">CL_EXIT</a>, <a href="#robo312">CL_TRACE</a>, <a href="#robo313">CL_TRACE_EXIT</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo312">[Definitions]<a name="Component20Library3a20Debug20Output2fCL5fTRACE">\r
+Component Library: Debug Output/CL_TRACE</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_definitions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>CL_TRACE</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>CL_TRACE</strong> macro sends a string to the current debug target if\r
+ the requested debug level matches the current debug level. The\r
+ output is prepended with the function name and, depending on the\r
+ debug level requested, an indication of the severity of the message.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>* <strong>CL_TRACE</strong>( DBG_LVL, CHK_LVL, STRING );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> DBG_LVL\r
+ [in] Debug level for the string to output\r
+\r
+ CHK_LVL\r
+ [in] Current debug level against which to check DBG_LVL\r
+\r
+ STRING\r
+ [in] String to send to the current debug target. The string includes\r
+ parentheses in order to allow additional parameters.\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> This macro does not return a value.\r
+</pre>\r
+</span><p><strong>EXAMPLE</strong></p>\r
+<span class="EXAMPLE"><pre> #define __MODULE__ "my_module"\r
+ #define MY_FUNC_DBG_LVL 1\r
+\r
+ uint32_t my_dbg_lvl = CL_DBG_ALL;\r
+\r
+ void\r
+ my_func()\r
+ {\r
+ <a href="#robo308">CL_ENTER</a>( MY_FUNC_DBG_LVL, my_dbg_lvl );\r
+ <strong>CL_TRACE</strong>( MY_FUNC_DBG_LVL, my_dbg_lvl, ("Hello %s!\n", "world") );\r
+ <a href="#robo309">CL_EXIT</a>( MY_FUNC_DBG_LVL, my_dbg_lvl );\r
+ }\r
+</pre>\r
+</span><p><strong>RESULT</strong></p>\r
+<span class="RESULT"><pre> my_module:my_func() [\r
+ my_module:my_func(): Hello world!\r
+ my_module:my_func() ]\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> The requested string is printed only if all bits set in DBG_LVL are also\r
+ set in CHK_LVL. CHK_LVL may have additional bits set.\r
+\r
+ The <strong>CL_TRACE</strong> macro must only be used after the CL_ENTRY macro as it\r
+ depends on that macro's implementation.\r
+\r
+ If the DBG_LVL has the upper bit set, the output will contain\r
+ an "!ERROR!" statement between the function name and STRING.\r
+\r
+ If the __MODULE__ preprocessor keyword is defined, that keyword will be\r
+ prepended to the function name, separated with a colon.\r
+\r
+ In multi-processor environments where the current processor can be\r
+ determined, the zero-based number of the processor on which the output\r
+ is generated is prepended to the output.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Debug Output, Debug Levels, <a href="#robo311">CL_PRINT</a>, <a href="#robo308">CL_ENTER</a>, <a href="#robo309">CL_EXIT</a>, <a href="#robo313">CL_TRACE_EXIT</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo313">[Definitions]<a name="Component20Library3a20Debug20Output2fCL5fTRACE5fEXIT">\r
+Component Library: Debug Output/CL_TRACE_EXIT</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_definitions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>CL_TRACE_EXIT</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>CL_TRACE_EXIT</strong> macro combines the functionality of the <a href="#robo312">CL_TRACE</a> and\r
+ <a href="#robo309">CL_EXIT</a> macros, in that order.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>* <strong>CL_TRACE_EXIT</strong>( DBG_LVL, CHK_LVL, STRING );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> DBG_LVL\r
+ [in] Debug level for the string to output\r
+\r
+ CHK_LVL\r
+ [in] Current debug level against which to check DBG_LVL\r
+\r
+ STRING\r
+ [in] String to send to the current debug target. The string includes\r
+ parentheses in order to allow additional parameters.\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> This macro does not return a value.\r
+</pre>\r
+</span><p><strong>EXAMPLE</strong></p>\r
+<span class="EXAMPLE"><pre> #define __MODULE__ "my_module"\r
+ #define MY_FUNC_DBG_LVL 1\r
+\r
+ uint32_t my_dbg_lvl = CL_DBG_ALL;\r
+\r
+ void\r
+ my_func()\r
+ {\r
+ <a href="#robo308">CL_ENTER</a>( MY_FUNC_DBG_LVL, my_dbg_lvl );\r
+ <strong>CL_TRACE_EXIT</strong>( MY_FUNC_DBG_LVL, my_dbg_lvl, ("Hello %s!\n", "world") );\r
+ }\r
+</pre>\r
+</span><p><strong>RESULT</strong></p>\r
+<span class="RESULT"><pre> my_module:my_func() [\r
+ my_module:my_func(): Hello world!\r
+ my_module:my_func() ]\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> The requested string is printed only if all bits set in DBG_LVL are also\r
+ set in CHK_LVL. CHK_LVL may have additional bits set.\r
+\r
+ The <strong>CL_TRACE_EXIT</strong> macro must only be used after the CL_ENTRY macro as it\r
+ depends on that macro's implementation.\r
+\r
+ If the DBG_LVL has the upper bit set, the output will contain\r
+ an "!ERROR!" statement between the function name and STRING.\r
+\r
+ If the __MODULE__ preprocessor keyword is defined, that keyword will be\r
+ prepended to the function name, separated with a colon.\r
+\r
+ In multi-processor environments where the current processor can be\r
+ determined, the zero-based number of the processor on which the output\r
+ is generated is prepended to the output.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Debug Output, Debug Levels, <a href="#robo311">CL_PRINT</a>, <a href="#robo308">CL_ENTER</a>, <a href="#robo309">CL_EXIT</a>, <a href="#robo312">CL_TRACE</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo314">[Definitions]<a name="Component20Library3a20Debug20Output2fDebug20Levels">\r
+Component Library: Debug Output/Debug Levels</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_definitions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> Debug Levels\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The debug output macros reserve the upper bit of the debug level to\r
+ convey an error.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>#define CL_DBG_DISABLE 0\r
+#define CL_DBG_ERROR 0x80000000\r
+#define CL_DBG_ALL 0xFFFFFFFF\r
+</pre>\r
+</span><p><strong>VALUES</strong></p>\r
+<span class="VALUES"><pre> CL_DBG_DISABLE\r
+ Disable all debug output, including errors.\r
+\r
+ CL_DBG_ERROR\r
+ Enable error debug output.\r
+\r
+ CL_DBG_ALL\r
+ Enbale all debug output.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> Users can define custom debug levels using the lower 31 bits of their\r
+ debug level to control non-error debug output. Error messages are\r
+ always displayed, regardless of the lower bit definition.\r
+\r
+ When specifying the debug output desired for non-error messages\r
+ (the CHK_LVL parameter in the debug output macros), users must define\r
+ all bits whose output they are interested in.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Debug Output, <a href="#robo311">CL_PRINT</a>, <a href="#robo308">CL_ENTER</a>, <a href="#robo309">CL_EXIT</a>, <a href="#robo312">CL_TRACE</a>, <a href="#robo313">CL_TRACE_EXIT</a>\r
+</pre>\r
+</span>\r
+</body>\r
+</html>\r
--- /dev/null
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">\r
+<html>\r
+<head>\r
+<link rel="stylesheet" href="../robodoc.css" type="text/css">\r
+<title>./inc_doc/complib/cl_event_h.html</title>\r
+<!-- Source: ./inc/complib/cl_event.h -->\r
+<!-- Generated with ROBODoc Version 4.99.22 (Mar 6 2006) -->\r
+</head>\r
+<body bgcolor="#FFFFFF">\r
+<a name="robo_top_of_doc">Generated from ./inc/complib/cl_event.h</a> with <a href="http://sourceforge.net/projects/robodoc/">ROBODoc</a> v4.99.22 on Sun Apr 16 2006 17:39:25\r
+<br />\r
+<hr />\r
+\r
+<h2><a name="robo11">[Modules]<a name="Component20Library2fEvent">\r
+Component Library/Event</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_modules.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>Event</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>Event</strong> provides the ability to suspend and wakeup a thread.\r
+\r
+ The event functions operates on a cl_event_t structure which should be\r
+ treated as opaque and should be manipulated only through the provided\r
+ functions.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Structures:\r
+ cl_event_t\r
+\r
+ Initialization/Destruction:\r
+ <a href="#robo316">cl_event_construct</a>, <a href="#robo318">cl_event_init</a>, <a href="#robo317">cl_event_destroy</a>\r
+\r
+ Manipulation:\r
+ <a href="#robo320">cl_event_signal</a>, <a href="#robo319">cl_event_reset</a>, <a href="#robo321">cl_event_wait_on</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo316">[Functions]<a name="Component20Library3a20Event2fcl5fevent5fconstruct">\r
+Component Library: Event/cl_event_construct</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_event_construct</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_event_construct</strong> function constructs an event.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT void CL_API\r
+<strong>cl_event_construct</strong>(\r
+ IN cl_event_t* const p_event );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_event\r
+ [in] Pointer to an cl_event_t structure to construct.\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> This function does not return a value.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> Allows calling <a href="#robo317">cl_event_destroy</a> without first calling <a href="#robo318">cl_event_init</a>.\r
+\r
+ Calling <strong>cl_event_construct</strong> is a prerequisite to calling any other event\r
+ function except <a href="#robo318">cl_event_init</a>.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> <a href="#robo11">Event</a>, <a href="#robo318">cl_event_init</a>, <a href="#robo317">cl_event_destroy</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo317">[Functions]<a name="Component20Library3a20Event2fcl5fevent5fdestroy">\r
+Component Library: Event/cl_event_destroy</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_event_destroy</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_event_destroy</strong> function performs any necessary cleanup of an event.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT void CL_API\r
+<strong>cl_event_destroy</strong>(\r
+ IN cl_event_t* const p_event );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_event\r
+ [in] Pointer to an cl_event_t structure to destroy.\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> This function does not return a value.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> This function should only be called after a call to <a href="#robo316">cl_event_construct</a>\r
+ or <a href="#robo318">cl_event_init</a>.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> <a href="#robo11">Event</a>, <a href="#robo316">cl_event_construct</a>, <a href="#robo318">cl_event_init</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo318">[Functions]<a name="Component20Library3a20Event2fcl5fevent5finit">\r
+Component Library: Event/cl_event_init</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_event_init</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_event_init</strong> function initializes an event for use.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT <a href="./cl_types_h.html#robo304">cl_status_t</a> CL_API\r
+<strong>cl_event_init</strong>(\r
+ IN cl_event_t* const p_event,\r
+ IN const boolean_t manual_reset );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_event\r
+ [in] Pointer to an cl_event_t structure to initialize.\r
+\r
+ manual_reset\r
+ [in] If FALSE, indicates that the event resets itself after releasing\r
+ a single waiter. If TRUE, the event remains in the signalled state\r
+ until explicitly reset by a call to <a href="#robo319">cl_event_reset</a>.\r
+\r
+ RETURN VALUES\r
+ CL_SUCCESS if event initialization succeeded.\r
+\r
+ CL_ERROR otherwise.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> Allows calling event manipulation functions, such as <a href="#robo320">cl_event_signal</a>,\r
+ <a href="#robo319">cl_event_reset</a>, and <a href="#robo321">cl_event_wait_on</a>.\r
+\r
+ The event is initially in a reset state.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> <a href="#robo11">Event</a>, <a href="#robo316">cl_event_construct</a>, <a href="#robo317">cl_event_destroy</a>, <a href="#robo320">cl_event_signal</a>,\r
+ <a href="#robo319">cl_event_reset</a>, <a href="#robo321">cl_event_wait_on</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo319">[Functions]<a name="Component20Library3a20Event2fcl5fevent5freset">\r
+Component Library: Event/cl_event_reset</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_event_reset</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_event_reset</strong> function sets an event to the non-signalled state.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT <a href="./cl_types_h.html#robo304">cl_status_t</a> CL_API\r
+<strong>cl_event_reset</strong>(\r
+ IN cl_event_t* const p_event );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_event\r
+ [in] Pointer to an cl_event_t structure to reset.\r
+\r
+ RETURN VALUES\r
+ CL_SUCCESS if the event was successfully reset.\r
+\r
+ CL_ERROR otherwise.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> <a href="#robo11">Event</a>, <a href="#robo320">cl_event_signal</a>, <a href="#robo321">cl_event_wait_on</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo320">[Functions]<a name="Component20Library3a20Event2fcl5fevent5fsignal">\r
+Component Library: Event/cl_event_signal</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_event_signal</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_event_signal</strong> function sets an event to the signalled state and\r
+ releases one or more waiting threads.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT <a href="./cl_types_h.html#robo304">cl_status_t</a> CL_API\r
+<strong>cl_event_signal</strong>(\r
+ IN cl_event_t* const p_event );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_event\r
+ [in] Pointer to an cl_event_t structure to set.\r
+\r
+ RETURN VALUES\r
+ CL_SUCCESS if the event was successfully signalled.\r
+\r
+ CL_ERROR otherwise.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> For auto-reset events, the event is reset automatically once a wait\r
+ operation is satisfied.\r
+\r
+ Triggering the event multiple times does not guarantee that the same\r
+ number of wait operations are satisfied. This is because events are\r
+ either in a signalled on non-signalled state, and triggering an event\r
+ that is already in the signalled state has no effect.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> <a href="#robo11">Event</a>, <a href="#robo319">cl_event_reset</a>, <a href="#robo321">cl_event_wait_on</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo321">[Functions]<a name="Component20Library3a20Event2fcl5fevent5fwait5fon">\r
+Component Library: Event/cl_event_wait_on</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_event_wait_on</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_event_wait_on</strong> function waits for the specified event to be\r
+ triggered for a minimum amount of time.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT <a href="./cl_types_h.html#robo304">cl_status_t</a> CL_API\r
+<strong>cl_event_wait_on</strong>(\r
+ IN cl_event_t* const p_event,\r
+ IN const uint32_t wait_us,\r
+ IN const boolean_t interruptible );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_event\r
+ [in] Pointer to an cl_event_t structure on which to wait.\r
+\r
+ wait_us\r
+ [in] Number of microseconds to wait.\r
+\r
+ interruptible\r
+ [in] Indicates whether the wait operation can be interrupted\r
+ by external signals.\r
+\r
+ RETURN VALUES\r
+ CL_SUCCESS if the wait operation succeeded in response to the event\r
+ being set.\r
+\r
+ CL_TIMEOUT if the specified time period elapses.\r
+\r
+ CL_NOT_DONE if the wait was interrupted by an external signal.\r
+\r
+ CL_ERROR if the wait operation failed.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> If wait_us is set to EVENT_NO_TIMEOUT, the function will wait until the\r
+ event is triggered and never timeout.\r
+\r
+ If the timeout value is zero, this function simply tests the state of\r
+ the event.\r
+\r
+ If the event is already in the signalled state at the time of the call\r
+ to <strong>cl_event_wait_on</strong>, the call completes immediately with CL_SUCCESS.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> <a href="#robo11">Event</a>, <a href="#robo320">cl_event_signal</a>, <a href="#robo319">cl_event_reset</a>\r
+</pre>\r
+</span>\r
+</body>\r
+</html>\r
--- /dev/null
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">\r
+<html>\r
+<head>\r
+<link rel="stylesheet" href="../robodoc.css" type="text/css">\r
+<title>./inc_doc/complib/cl_fleximap_h.html</title>\r
+<!-- Source: ./inc/complib/cl_fleximap.h -->\r
+<!-- Generated with ROBODoc Version 4.99.22 (Mar 6 2006) -->\r
+</head>\r
+<body bgcolor="#FFFFFF">\r
+<a name="robo_top_of_doc">Generated from ./inc/complib/cl_fleximap.h</a> with <a href="http://sourceforge.net/projects/robodoc/">ROBODoc</a> v4.99.22 on Sun Apr 16 2006 17:39:25\r
+<br />\r
+<hr />\r
+\r
+<h2><a name="robo12">[Modules]<a name="Component20Library2fFlexi20Map">\r
+Component Library/Flexi Map</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_modules.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> Flexi <a href="./cl_map_h.html#robo17">Map</a>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> Flexi map implements a binary tree that stores user provided <a href="#robo331">cl_fmap_item_t</a>\r
+ structures. Each item stored in a flexi map has a unique user defined key\r
+ (duplicates are not allowed). Flexi map provides the ability to\r
+ efficiently search for an item given a key. Flexi map allows user defined\r
+ keys of any size. Storage for keys and a comparisson function are provided\r
+ by users to allow flexi map to store items with arbitrary key values.\r
+\r
+ Flexi map does not allocate any memory, and can therefore not fail\r
+ any operations due to insufficient memory. Flexi map can thus be useful\r
+ in minimizing the error paths in code.\r
+\r
+ Flexi map is not thread safe, and users must provide serialization when\r
+ adding and removing items from the map.\r
+\r
+ The flexi map functions operate on a <a href="#robo339">cl_fmap_t</a> structure which should\r
+ be treated as opaque and should be manipulated only through the provided\r
+ functions.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Structures:\r
+ <a href="#robo339">cl_fmap_t</a>, <a href="#robo331">cl_fmap_item_t</a>\r
+\r
+ Callbacks:\r
+ <a href="#robo342">cl_pfn_fmap_apply_t</a>\r
+\r
+ Item Manipulation:\r
+ <a href="#robo332">cl_fmap_key</a>\r
+\r
+ Initialization:\r
+ <a href="#robo329">cl_fmap_init</a>\r
+\r
+ Iteration:\r
+ <a href="#robo326">cl_fmap_end</a>, <a href="#robo328">cl_fmap_head</a>, <a href="#robo340">cl_fmap_tail</a>, <a href="#robo334">cl_fmap_next</a>, <a href="#robo335">cl_fmap_prev</a>\r
+\r
+ Manipulation:\r
+ <a href="#robo330">cl_fmap_insert</a>, <a href="#robo327">cl_fmap_get</a>, <a href="#robo338">cl_fmap_remove_item</a>, <a href="#robo336">cl_fmap_remove</a>,\r
+ <a href="#robo337">cl_fmap_remove_all</a>, <a href="#robo333">cl_fmap_merge</a>, <a href="#robo325">cl_fmap_delta</a>\r
+\r
+ Search:\r
+ <a href="#robo323">cl_fmap_apply_func</a>\r
+\r
+ Attributes:\r
+ <a href="#robo324">cl_fmap_count</a>, <a href="#robo341">cl_is_fmap_empty</a>,\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo323">[Functions]<a name="Component20Library3a20Flexi20Map2fcl5ffmap5fapply5ffunc">\r
+Component Library: Flexi Map/cl_fmap_apply_func</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_fmap_apply_func</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_fmap_apply_func</strong> function executes a specified function\r
+ for every item stored in a flexi map.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT void CL_API\r
+<strong>cl_fmap_apply_func</strong>(\r
+ IN const <a href="#robo339">cl_fmap_t</a>* const p_map,\r
+ IN <a href="#robo342">cl_pfn_fmap_apply_t</a> pfn_func,\r
+ IN const void* const context );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_map\r
+ [in] Pointer to a <a href="#robo339">cl_fmap_t</a> structure.\r
+\r
+ pfn_func\r
+ [in] Function invoked for every item in the flexi map.\r
+ See the <a href="#robo342">cl_pfn_fmap_apply_t</a> function type declaration for details\r
+ about the callback function.\r
+\r
+ context\r
+ [in] Value to pass to the callback functions to provide context.\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> This function does not return a value.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> The function provided must not perform any map operations, as these\r
+ would corrupt the flexi map.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Flexi <a href="./cl_map_h.html#robo17">Map</a>, <a href="#robo342">cl_pfn_fmap_apply_t</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo324">[Functions]<a name="Component20Library3a20Flexi20Map2fcl5ffmap5fcount">\r
+Component Library: Flexi Map/cl_fmap_count</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_fmap_count</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_fmap_count</strong> function returns the number of items stored\r
+ in a flexi map.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_INLINE size_t CL_API\r
+<strong>cl_fmap_count</strong>(\r
+ IN const <a href="#robo339">cl_fmap_t</a>* const p_map )\r
+{\r
+ CL_ASSERT( p_map );\r
+ CL_ASSERT( p_map->state == CL_INITIALIZED );\r
+ return( p_map->count );\r
+}\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_map\r
+ [in] Pointer to a <a href="#robo339">cl_fmap_t</a> structure whose item count to return.\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> Returns the number of items stored in the map.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Flexi <a href="./cl_map_h.html#robo17">Map</a>, <a href="#robo341">cl_is_fmap_empty</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo325">[Functions]<a name="Component20Library3a20Flexi20Map2fcl5ffmap5fdelta">\r
+Component Library: Flexi Map/cl_fmap_delta</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_fmap_delta</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_fmap_delta</strong> function computes the differences between two maps.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT void CL_API\r
+<strong>cl_fmap_delta</strong>(\r
+ IN OUT <a href="#robo339">cl_fmap_t</a>* const p_map1,\r
+ IN OUT <a href="#robo339">cl_fmap_t</a>* const p_map2,\r
+ OUT <a href="#robo339">cl_fmap_t</a>* const p_new,\r
+ OUT <a href="#robo339">cl_fmap_t</a>* const p_old );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_map1\r
+ [in/out] Pointer to the first of two <a href="#robo339">cl_fmap_t</a> structures whose\r
+ differences to compute.\r
+\r
+ p_map2\r
+ [in/out] Pointer to the second of two <a href="#robo339">cl_fmap_t</a> structures whose\r
+ differences to compute.\r
+\r
+ p_new\r
+ [out] Pointer to an empty <a href="#robo339">cl_fmap_t</a> structure that contains the items\r
+ unique to p_map2 upon return from the function.\r
+\r
+ p_old\r
+ [out] Pointer to an empty <a href="#robo339">cl_fmap_t</a> structure that contains the items\r
+ unique to p_map1 upon return from the function.\r
+\r
+ RETURN VALUES\r
+ This function does not return a value.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> Items are evaluated based on their keys. Items that exist in both\r
+ p_map1 and p_map2 remain in their respective maps. Items that\r
+ exist only p_map1 are moved to p_old. Likewise, items that exist only\r
+ in p_map2 are moved to p_new. This function can be usefull in evaluating\r
+ changes between two maps.\r
+\r
+ Both maps pointed to by p_new and p_old must be empty on input. This\r
+ requirement removes the possibility of failures.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Flexi <a href="./cl_map_h.html#robo17">Map</a>, <a href="#robo333">cl_fmap_merge</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo326">[Functions]<a name="Component20Library3a20Flexi20Map2fcl5ffmap5fend">\r
+Component Library: Flexi Map/cl_fmap_end</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_fmap_end</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_fmap_end</strong> function returns the end of a flexi map.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_INLINE const <a href="#robo331">cl_fmap_item_t</a>* const CL_API\r
+<strong>cl_fmap_end</strong>(\r
+ IN const <a href="#robo339">cl_fmap_t</a>* const p_map )\r
+{\r
+ CL_ASSERT( p_map );\r
+ CL_ASSERT( p_map->state == CL_INITIALIZED );\r
+ /* Nil is the end of the map. */\r
+ return( &p_map->nil );\r
+}\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_map\r
+ [in] Pointer to a <a href="#robo339">cl_fmap_t</a> structure whose end to return.\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> Pointer to the end of the map.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> <strong>cl_fmap_end</strong> is useful for determining the validity of map items returned\r
+ by <a href="#robo328">cl_fmap_head</a>, <a href="#robo340">cl_fmap_tail</a>, <a href="#robo334">cl_fmap_next</a>, or <a href="#robo335">cl_fmap_prev</a>. If the map\r
+ item pointer returned by any of these functions compares to the end, the\r
+ end of the map was encoutered.\r
+ When using <a href="#robo328">cl_fmap_head</a> or <a href="#robo340">cl_fmap_tail</a>, this condition indicates that\r
+ the map is empty.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Flexi <a href="./cl_map_h.html#robo17">Map</a>, <a href="#robo328">cl_fmap_head</a>, <a href="#robo340">cl_fmap_tail</a>, <a href="#robo334">cl_fmap_next</a>, <a href="#robo335">cl_fmap_prev</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo327">[Functions]<a name="Component20Library3a20Flexi20Map2fcl5ffmap5fget">\r
+Component Library: Flexi Map/cl_fmap_get</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_fmap_get</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_fmap_get</strong> function returns the map item associated with a key.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT <a href="#robo331">cl_fmap_item_t</a>* CL_API\r
+<strong>cl_fmap_get</strong>(\r
+ IN const <a href="#robo339">cl_fmap_t</a>* const p_map,\r
+ IN const void* const p_key );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_map\r
+ [in] Pointer to a <a href="#robo339">cl_fmap_t</a> structure from which to retrieve the\r
+ item with the specified key.\r
+\r
+ p_key\r
+ [in] Pointer to a key value used to search for the desired map item.\r
+\r
+ RETURN VALUES\r
+ Pointer to the map item with the desired key value.\r
+\r
+ Pointer to the map end if there was no item with the desired key value\r
+ stored in the flexi map.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> <strong>cl_fmap_get</strong> does not remove the item from the flexi map.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Flexi <a href="./cl_map_h.html#robo17">Map</a>, <a href="#robo336">cl_fmap_remove</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo328">[Functions]<a name="Component20Library3a20Flexi20Map2fcl5ffmap5fhead">\r
+Component Library: Flexi Map/cl_fmap_head</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_fmap_head</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_fmap_head</strong> function returns the map item with the lowest key\r
+ value stored in a flexi map.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_INLINE <a href="#robo331">cl_fmap_item_t</a>* CL_API\r
+<strong>cl_fmap_head</strong>(\r
+ IN const <a href="#robo339">cl_fmap_t</a>* const p_map )\r
+{\r
+ CL_ASSERT( p_map );\r
+ CL_ASSERT( p_map->state == CL_INITIALIZED );\r
+ return( (<a href="#robo331">cl_fmap_item_t</a>*)p_map->nil.pool_item.list_item.p_next );\r
+}\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_map\r
+ [in] Pointer to a <a href="#robo339">cl_fmap_t</a> structure whose item with the lowest key\r
+ is returned.\r
+\r
+ RETURN VALUES\r
+ Pointer to the map item with the lowest key in the flexi map.\r
+\r
+ Pointer to the map end if the flexi map was empty.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> <strong>cl_fmap_head</strong> does not remove the item from the map.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Flexi <a href="./cl_map_h.html#robo17">Map</a>, <a href="#robo340">cl_fmap_tail</a>, <a href="#robo334">cl_fmap_next</a>, <a href="#robo335">cl_fmap_prev</a>, <a href="#robo326">cl_fmap_end</a>,\r
+ <a href="#robo331">cl_fmap_item_t</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo329">[Functions]<a name="Component20Library3a20Flexi20Map2fcl5ffmap5finit">\r
+Component Library: Flexi Map/cl_fmap_init</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_fmap_init</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_fmap_init</strong> function initialized a flexi map for use.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT void CL_API\r
+<strong>cl_fmap_init</strong>(\r
+ IN <a href="#robo339">cl_fmap_t</a>* const p_map,\r
+ IN <a href="#robo343">cl_pfn_fmap_cmp_t</a> pfn_compare );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_map\r
+ [in] Pointer to a <a href="#robo339">cl_fmap_t</a> structure to initialize.\r
+\r
+ pfn_compare\r
+ [in] Pointer to the compare function used to compare keys.\r
+ See the <a href="#robo343">cl_pfn_fmap_cmp_t</a> function type declaration for details\r
+ about the callback function.\r
+\r
+ RETURN VALUES\r
+ This function does not return a value.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> Allows calling flexi map manipulation functions.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Flexi <a href="./cl_map_h.html#robo17">Map</a>, <a href="#robo330">cl_fmap_insert</a>, <a href="#robo336">cl_fmap_remove</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo330">[Functions]<a name="Component20Library3a20Flexi20Map2fcl5ffmap5finsert">\r
+Component Library: Flexi Map/cl_fmap_insert</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_fmap_insert</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_fmap_insert</strong> function inserts a map item into a flexi map.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT <a href="#robo331">cl_fmap_item_t</a>* CL_API\r
+<strong>cl_fmap_insert</strong>(\r
+ IN <a href="#robo339">cl_fmap_t</a>* const p_map,\r
+ IN const void* const p_key,\r
+ IN <a href="#robo331">cl_fmap_item_t</a>* const p_item );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_map\r
+ [in] Pointer to a <a href="#robo339">cl_fmap_t</a> structure into which to add the item.\r
+\r
+ p_key\r
+ [in] Pointer to the key value to assign to the item. Storage for\r
+ the key must be persistant, as only the pointer is stored. Users\r
+ are responsible for maintaining the validity of key pointers while\r
+ they are in use.\r
+\r
+ p_item\r
+ [in] Pointer to a <a href="#robo331">cl_fmap_item_t</a> stucture to insert into the flexi map.\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> Pointer to the item in the map with the specified key. If insertion\r
+ was successful, this is the pointer to the item. If an item with the\r
+ specified key already exists in the map, the pointer to that item is\r
+ returned.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> Insertion operations may cause the flexi map to rebalance.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Flexi <a href="./cl_map_h.html#robo17">Map</a>, <a href="#robo336">cl_fmap_remove</a>, <a href="#robo331">cl_fmap_item_t</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo331">[Structures]<a name="Component20Library3a20Flexi20Map2fcl5ffmap5fitem5ft">\r
+Component Library: Flexi Map/cl_fmap_item_t</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_strutures.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_fmap_item_t</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_fmap_item_t</strong> structure is used by maps to store objects.\r
+\r
+ The <strong>cl_fmap_item_t</strong> structure should be treated as opaque and should\r
+ be manipulated only through the provided functions.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>typedef struct _cl_fmap_item\r
+{\r
+ /* Must be first to allow casting. */\r
+ <a href="./cl_qcomppool_h.html#robo542">cl_pool_item_t</a> pool_item;\r
+ struct _cl_fmap_item *p_left;\r
+ struct _cl_fmap_item *p_right;\r
+ struct _cl_fmap_item *p_up;\r
+ cl_map_color_t color;\r
+ const void* __ptr64 p_key;\r
+#ifdef _DEBUG_\r
+ struct _cl_fmap *p_map;\r
+#endif\r
+\r
+} <strong>cl_fmap_item_t</strong>;\r
+</pre>\r
+</span><p><strong>FIELDS</strong></p>\r
+<span class="FIELDS"><pre> pool_item\r
+ Used to store the item in a doubly linked list, allowing more\r
+ efficient map traversal.\r
+\r
+ p_left\r
+ Pointer to the map item that is a child to the left of the node.\r
+\r
+ p_right\r
+ Pointer to the map item that is a child to the right of the node.\r
+\r
+ p_up\r
+ Pointer to the map item that is the parent of the node.\r
+\r
+ p_nil\r
+ Pointer to the map's NIL item, used as a terminator for leaves.\r
+ The NIL sentinel is in the <a href="#robo339">cl_fmap_t</a> structure.\r
+\r
+ color\r
+ Indicates whether a node is red or black in the map.\r
+\r
+ p_key\r
+ Pointer to the value that uniquely represents a node in a map. This\r
+ pointer is set by calling <a href="#robo330">cl_fmap_insert</a> and can be retrieved by\r
+ calling <a href="#robo332">cl_fmap_key</a>.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> None of the fields of this structure should be manipulated by users, as\r
+ they are crititcal to the proper operation of the map in which they\r
+ are stored.\r
+\r
+ To allow storing items in either a quick list, a quick pool, or a flexi\r
+ map, the map implementation guarantees that the map item can be safely\r
+ cast to a pool item used for storing an object in a quick pool, or cast to\r
+ a list item used for storing an object in a quick list. This removes the\r
+ need to embed a flexi map item, a list item, and a pool item in objects\r
+ that need to be stored in a quick list, a quick pool, and a flexi map.\r
+\r
+ The flexi map item is defined to be identical in layout as a map item.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Flexi <a href="./cl_map_h.html#robo17">Map</a>, <a href="#robo330">cl_fmap_insert</a>, <a href="#robo332">cl_fmap_key</a>, <a href="./cl_qcomppool_h.html#robo542">cl_pool_item_t</a>, <a href="./cl_qlist_h.html#robo554">cl_list_item_t</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo332">[Functions]<a name="Component20Library3a20Flexi20Map2fcl5ffmap5fkey">\r
+Component Library: Flexi Map/cl_fmap_key</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_fmap_key</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_fmap_key</strong> function retrieves the key value of a map item.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>#pragma warning (push)\r
+#pragma warning (disable :4244)\r
+CL_INLINE const void* CL_API\r
+<strong>cl_fmap_key</strong>(\r
+ IN const <a href="#robo331">cl_fmap_item_t</a>* const p_item )\r
+{\r
+ CL_ASSERT( p_item );\r
+ return( p_item->p_key );\r
+}\r
+#pragma warning (pop )\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_item\r
+ [in] Pointer to a map item whose key value to return.\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> Returns the a pointer to the key value for the specified map item.\r
+ The key value should not be modified to insure proper flexi map operation.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> The key value is set in a call to <a href="#robo330">cl_fmap_insert</a>.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Flexi <a href="./cl_map_h.html#robo17">Map</a>, <a href="#robo330">cl_fmap_insert</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo333">[Functions]<a name="Component20Library3a20Flexi20Map2fcl5ffmap5fmerge">\r
+Component Library: Flexi Map/cl_fmap_merge</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_fmap_merge</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_fmap_merge</strong> function moves all items from one map to another,\r
+ excluding duplicates.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT void CL_API\r
+<strong>cl_fmap_merge</strong>(\r
+ OUT <a href="#robo339">cl_fmap_t</a>* const p_dest_map,\r
+ IN OUT <a href="#robo339">cl_fmap_t</a>* const p_src_map );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_dest_map\r
+ [out] Pointer to a <a href="#robo339">cl_fmap_t</a> structure to which items should be added.\r
+\r
+ p_src_map\r
+ [in/out] Pointer to a <a href="#robo339">cl_fmap_t</a> structure whose items to add\r
+ to p_dest_map.\r
+\r
+ RETURN VALUES\r
+ This function does not return a value.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> Items are evaluated based on their keys only.\r
+\r
+ Upon return from <strong>cl_fmap_merge</strong>, the flexi map referenced by p_src_map\r
+ contains all duplicate items.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Flexi <a href="./cl_map_h.html#robo17">Map</a>, <a href="#robo325">cl_fmap_delta</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo334">[Functions]<a name="Component20Library3a20Flexi20Map2fcl5ffmap5fnext">\r
+Component Library: Flexi Map/cl_fmap_next</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_fmap_next</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_fmap_next</strong> function returns the map item with the next higher\r
+ key value than a specified map item.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_INLINE <a href="#robo331">cl_fmap_item_t</a>* CL_API\r
+<strong>cl_fmap_next</strong>(\r
+ IN const <a href="#robo331">cl_fmap_item_t</a>* const p_item )\r
+{\r
+ CL_ASSERT( p_item );\r
+ return( (<a href="#robo331">cl_fmap_item_t</a>*)p_item->pool_item.list_item.p_next );\r
+}\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_item\r
+ [in] Pointer to a map item whose successor to return.\r
+\r
+ RETURN VALUES\r
+ Pointer to the map item with the next higher key value in a flexi map.\r
+\r
+ Pointer to the map end if the specified item was the last item in\r
+ the flexi map.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Flexi <a href="./cl_map_h.html#robo17">Map</a>, <a href="#robo328">cl_fmap_head</a>, <a href="#robo340">cl_fmap_tail</a>, <a href="#robo335">cl_fmap_prev</a>, <a href="#robo326">cl_fmap_end</a>,\r
+ <a href="#robo331">cl_fmap_item_t</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo335">[Functions]<a name="Component20Library3a20Flexi20Map2fcl5ffmap5fprev">\r
+Component Library: Flexi Map/cl_fmap_prev</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_fmap_prev</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_fmap_prev</strong> function returns the map item with the next lower\r
+ key value than a precified map item.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_INLINE <a href="#robo331">cl_fmap_item_t</a>* CL_API\r
+<strong>cl_fmap_prev</strong>(\r
+ IN const <a href="#robo331">cl_fmap_item_t</a>* const p_item )\r
+{\r
+ CL_ASSERT( p_item );\r
+ return( (<a href="#robo331">cl_fmap_item_t</a>*)p_item->pool_item.list_item.p_prev );\r
+}\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_item\r
+ [in] Pointer to a map item whose predecessor to return.\r
+\r
+ RETURN VALUES\r
+ Pointer to the map item with the next lower key value in a flexi map.\r
+\r
+ Pointer to the map end if the specifid item was the first item in\r
+ the flexi map.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Flexi <a href="./cl_map_h.html#robo17">Map</a>, <a href="#robo328">cl_fmap_head</a>, <a href="#robo340">cl_fmap_tail</a>, <a href="#robo334">cl_fmap_next</a>, <a href="#robo326">cl_fmap_end</a>,\r
+ <a href="#robo331">cl_fmap_item_t</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo336">[Functions]<a name="Component20Library3a20Flexi20Map2fcl5ffmap5fremove">\r
+Component Library: Flexi Map/cl_fmap_remove</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_fmap_remove</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_fmap_remove</strong> function removes the map item with the specified key\r
+ from a flexi map.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT <a href="#robo331">cl_fmap_item_t</a>* CL_API\r
+<strong>cl_fmap_remove</strong>(\r
+ IN <a href="#robo339">cl_fmap_t</a>* const p_map,\r
+ IN const void* const p_key );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_map\r
+ [in] Pointer to a <a href="#robo339">cl_fmap_t</a> structure from which to remove the item\r
+ with the specified key.\r
+\r
+ p_key\r
+ [in] Pointer to the key value used to search for the map item\r
+ to remove.\r
+\r
+ RETURN VALUES\r
+ Pointer to the removed map item if it was found.\r
+\r
+ Pointer to the map end if no item with the specified key exists in the\r
+ flexi map.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Flexi <a href="./cl_map_h.html#robo17">Map</a>, <a href="#robo338">cl_fmap_remove_item</a>, <a href="#robo337">cl_fmap_remove_all</a>, <a href="#robo330">cl_fmap_insert</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo337">[Functions]<a name="Component20Library3a20Flexi20Map2fcl5ffmap5fremove5fall">\r
+Component Library: Flexi Map/cl_fmap_remove_all</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_fmap_remove_all</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_fmap_remove_all</strong> function removes all items in a flexi map,\r
+ leaving it empty.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_INLINE void CL_API\r
+<strong>cl_fmap_remove_all</strong>(\r
+ IN <a href="#robo339">cl_fmap_t</a>* const p_map )\r
+{\r
+ CL_ASSERT( p_map );\r
+ CL_ASSERT( p_map->state == CL_INITIALIZED );\r
+\r
+ p_map->root.p_left = &p_map->nil;\r
+ p_map->nil.pool_item.list_item.p_next = &p_map->nil.pool_item.list_item;\r
+ p_map->nil.pool_item.list_item.p_prev = &p_map->nil.pool_item.list_item;\r
+ p_map->count = 0;\r
+}\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_map\r
+ [in] Pointer to a <a href="#robo339">cl_fmap_t</a> structure to empty.\r
+\r
+ RETURN VALUES\r
+ This function does not return a value.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Flexi <a href="./cl_map_h.html#robo17">Map</a>, <a href="#robo336">cl_fmap_remove</a>, <a href="#robo338">cl_fmap_remove_item</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo338">[Functions]<a name="Component20Library3a20Flexi20Map2fcl5ffmap5fremove5fitem">\r
+Component Library: Flexi Map/cl_fmap_remove_item</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_fmap_remove_item</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_fmap_remove_item</strong> function removes the specified map item\r
+ from a flexi map.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT void CL_API\r
+<strong>cl_fmap_remove_item</strong>(\r
+ IN <a href="#robo339">cl_fmap_t</a>* const p_map,\r
+ IN <a href="#robo331">cl_fmap_item_t</a>* const p_item );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_item\r
+ [in] Pointer to a map item to remove from its flexi map.\r
+\r
+ RETURN VALUES\r
+ This function does not return a value.\r
+\r
+ In a debug build, <strong>cl_fmap_remove_item</strong> asserts that the item being removed\r
+ is in the specified map.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> Removes the map item pointed to by p_item from its flexi map.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Flexi <a href="./cl_map_h.html#robo17">Map</a>, <a href="#robo336">cl_fmap_remove</a>, <a href="#robo337">cl_fmap_remove_all</a>, <a href="#robo330">cl_fmap_insert</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo339">[Structures]<a name="Component20Library3a20Flexi20Map2fcl5ffmap5ft">\r
+Component Library: Flexi Map/cl_fmap_t</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_strutures.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_fmap_t</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> Flexi map structure.\r
+\r
+ The <strong>cl_fmap_t</strong> structure should be treated as opaque and should\r
+ be manipulated only through the provided functions.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>typedef struct _cl_fmap\r
+{\r
+ <a href="#robo331">cl_fmap_item_t</a> root;\r
+ <a href="#robo331">cl_fmap_item_t</a> nil;\r
+ cl_state_t state;\r
+ size_t count;\r
+ <a href="#robo343">cl_pfn_fmap_cmp_t</a> pfn_compare;\r
+\r
+} <strong>cl_fmap_t</strong>;\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> root\r
+ <a href="./cl_map_h.html#robo17">Map</a> item that serves as root of the map. The root is set up to\r
+ always have itself as parent. The left pointer is set to point to\r
+ the item at the root.\r
+\r
+ nil\r
+ <a href="./cl_map_h.html#robo17">Map</a> item that serves as terminator for all leaves, as well as providing\r
+ the list item used as quick list for storing map items in a list for\r
+ faster traversal.\r
+\r
+ state\r
+ State of the map, used to verify that operations are permitted.\r
+\r
+ count\r
+ Number of items in the map.\r
+\r
+ pfn_compare\r
+ Pointer to a compare function to invoke to compare the keys of\r
+ items in the map.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Flexi <a href="./cl_map_h.html#robo17">Map</a>, <a href="#robo343">cl_pfn_fmap_cmp_t</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo340">[Functions]<a name="Component20Library3a20Flexi20Map2fcl5ffmap5ftail">\r
+Component Library: Flexi Map/cl_fmap_tail</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_fmap_tail</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_fmap_tail</strong> function returns the map item with the highest key\r
+ value stored in a flexi map.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_INLINE <a href="#robo331">cl_fmap_item_t</a>* CL_API\r
+<strong>cl_fmap_tail</strong>(\r
+ IN const <a href="#robo339">cl_fmap_t</a>* const p_map )\r
+{\r
+ CL_ASSERT( p_map );\r
+ CL_ASSERT( p_map->state == CL_INITIALIZED );\r
+ return( (<a href="#robo331">cl_fmap_item_t</a>*)p_map->nil.pool_item.list_item.p_prev );\r
+}\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_map\r
+ [in] Pointer to a <a href="#robo339">cl_fmap_t</a> structure whose item with the highest key\r
+ is returned.\r
+\r
+ RETURN VALUES\r
+ Pointer to the map item with the highest key in the flexi map.\r
+\r
+ Pointer to the map end if the flexi map was empty.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> <a href="#robo326">cl_fmap_end</a> does not remove the item from the map.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Flexi <a href="./cl_map_h.html#robo17">Map</a>, <a href="#robo328">cl_fmap_head</a>, <a href="#robo334">cl_fmap_next</a>, <a href="#robo335">cl_fmap_prev</a>, <a href="#robo326">cl_fmap_end</a>,\r
+ <a href="#robo331">cl_fmap_item_t</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo341">[Functions]<a name="Component20Library3a20Flexi20Map2fcl5fis5ffmap5fempty">\r
+Component Library: Flexi Map/cl_is_fmap_empty</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_is_fmap_empty</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_is_fmap_empty</strong> function returns whether a flexi map is empty.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_INLINE boolean_t CL_API\r
+<strong>cl_is_fmap_empty</strong>(\r
+ IN const <a href="#robo339">cl_fmap_t</a>* const p_map )\r
+{\r
+ CL_ASSERT( p_map );\r
+ CL_ASSERT( p_map->state == CL_INITIALIZED );\r
+\r
+ return( p_map->count == 0 );\r
+}\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_map\r
+ [in] Pointer to a <a href="#robo339">cl_fmap_t</a> structure to test for emptiness.\r
+\r
+ RETURN VALUES\r
+ TRUE if the flexi map is empty.\r
+\r
+ FALSE otherwise.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Flexi <a href="./cl_map_h.html#robo17">Map</a>, <a href="#robo324">cl_fmap_count</a>, <a href="#robo337">cl_fmap_remove_all</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo342">[Definitions]<a name="Component20Library3a20Flexi20Map2fcl5fpfn5ffmap5fapply5ft">\r
+Component Library: Flexi Map/cl_pfn_fmap_apply_t</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_definitions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_pfn_fmap_apply_t</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_pfn_fmap_apply_t</strong> function type defines the prototype for functions\r
+ used to iterate items in a flexi map.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>typedef void\r
+(CL_API *<strong>cl_pfn_fmap_apply_t</strong>)(\r
+ IN <a href="#robo331">cl_fmap_item_t</a>* const p_map_item,\r
+ IN void* context );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_map_item\r
+ [in] Pointer to a <a href="#robo331">cl_fmap_item_t</a> structure.\r
+\r
+ context\r
+ [in] Value passed to the callback function.\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> This function does not return a value.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> This function type is provided as function prototype reference for the\r
+ function provided by users as a parameter to the <a href="#robo323">cl_fmap_apply_func</a>\r
+ function.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Flexi <a href="./cl_map_h.html#robo17">Map</a>, <a href="#robo323">cl_fmap_apply_func</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo343">[Definitions]<a name="Component20Library3a20Flexi20Map2fcl5fpfn5ffmap5fcmp5ft">\r
+Component Library: Flexi Map/cl_pfn_fmap_cmp_t</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_definitions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_pfn_fmap_cmp_t</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_pfn_fmap_cmp_t</strong> function type defines the prototype for functions\r
+ used to compare item keys in a flexi map.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>typedef intn_t\r
+(CL_API *<strong>cl_pfn_fmap_cmp_t</strong>)(\r
+ IN const void* const p_key1,\r
+ IN const void* const p_key2 );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_key1\r
+ [in] Pointer to the first of two keys to compare.\r
+\r
+ p_key2\r
+ [in] Pointer to the second of two keys to compare.\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> Returns 0 if the keys match.\r
+ Returns less than 0 if p_key1 is less than p_key2.\r
+ Returns greater than 0 if p_key1 is greater than p_key2.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> This function type is provided as function prototype reference for the\r
+ function provided by users as a parameter to the <a href="#robo329">cl_fmap_init</a> function.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Flexi <a href="./cl_map_h.html#robo17">Map</a>, <a href="#robo329">cl_fmap_init</a>\r
+</pre>\r
+</span>\r
+</body>\r
+</html>\r
--- /dev/null
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">\r
+<html>\r
+<head>\r
+<link rel="stylesheet" href="../robodoc.css" type="text/css">\r
+<title>./inc_doc/complib/cl_ioctl_h.html</title>\r
+<!-- Source: ./inc/complib/cl_ioctl.h -->\r
+<!-- Generated with ROBODoc Version 4.99.22 (Mar 6 2006) -->\r
+</head>\r
+<body bgcolor="#FFFFFF">\r
+<a name="robo_top_of_doc">Generated from ./inc/complib/cl_ioctl.h</a> with <a href="http://sourceforge.net/projects/robodoc/">ROBODoc</a> v4.99.22 on Sun Apr 16 2006 17:39:25\r
+<br />\r
+<hr />\r
+\r
+<h2><a name="robo13">[Modules]<a name="Component20Library2fIOCTL20Object">\r
+Component Library/IOCTL Object</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_modules.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> IOCTL <a href="./cl_obj_h.html#robo18">Object</a>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The IOCTL object provides functionality for handling IOCTL requests.\r
+\r
+ The IOCTL object is only available in kernel mode and provides\r
+ functionality for accessing information about IO requests initiated\r
+ by a user-mode application. The <a href="#robo357">IOCTL_CODE</a> macro is used in both\r
+ user and kernel mode to initiate and dispatch IOCTL requests, respectively.\r
+\r
+ In Linux, in order for the IOCTL object to be used, requests must be\r
+ initiated and handled using the Device Framework abstraction.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Structures:\r
+ <a href="#robo347">cl_ioctl_handle_t</a>\r
+\r
+ Callbacks:\r
+ <a href="#robo356">cl_pfn_ioctl_handler_t</a>\r
+\r
+ Control Code Generation\r
+ <a href="#robo357">IOCTL_CODE</a>\r
+\r
+ Kernel Mode Access\r
+ <a href="#robo352">cl_ioctl_process</a>\r
+ <a href="#robo345">cl_ioctl_complete</a>\r
+ <a href="#robo355">cl_ioctl_type</a>\r
+ <a href="#robo344">cl_ioctl_cmd</a>\r
+ <a href="#robo346">cl_ioctl_ctl_code</a>\r
+ <a href="#robo348">cl_ioctl_in_buf</a>\r
+ <a href="#robo349">cl_ioctl_in_size</a>\r
+ <a href="#robo350">cl_ioctl_out_buf</a>\r
+ <a href="#robo351">cl_ioctl_out_size</a>\r
+\r
+ User Mode Access\r
+ <a href="#robo353">cl_ioctl_request</a>\r
+ <a href="#robo354">cl_ioctl_result</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo344">[Functions]<a name="Component20Library3a20IOCTL20Object2fcl5fioctl5fcmd">\r
+Component Library: IOCTL Object/cl_ioctl_cmd</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_ioctl_cmd</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> Returns the command of an IOCTL\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT uint16_t CL_API\r
+<strong>cl_ioctl_cmd</strong>(\r
+ IN <a href="#robo347">cl_ioctl_handle_t</a> h_ioctl );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> h_ioctl\r
+ [in] Handle to an IOCTL\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> Returns the command of the specified IOCTL request, as defined using\r
+ the IOCTL_CMD macro.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> The <strong>cl_ioctl_cmd</strong> function is only available in the kernel.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> IOCTL <a href="./cl_obj_h.html#robo18">Object</a>, <a href="#robo347">cl_ioctl_handle_t</a>, <a href="#robo355">cl_ioctl_type</a>, <a href="#robo346">cl_ioctl_ctl_code</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo345">[Functions]<a name="Component20Library3a20IOCTL20Object2fcl5fioctl5fcomplete">\r
+Component Library: IOCTL Object/cl_ioctl_complete</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_ioctl_complete</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> Fills in completion information for an IOCTL and releases the IOCTL request\r
+ for completion.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT void CL_API\r
+<strong>cl_ioctl_complete</strong>(\r
+ IN <a href="#robo347">cl_ioctl_handle_t</a> h_ioctl,\r
+ IN <a href="./cl_types_h.html#robo304">cl_status_t</a> io_status,\r
+ IN size_t ret_bytes );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> h_ioctl\r
+ Handle to the IOCTL being completed. This handle was provided to\r
+ the IOCTL handler.\r
+\r
+ io_status\r
+ Status of the IOCTL request.\r
+\r
+ ret_bytes\r
+ Number of bytes written to the output buffer.\r
+\r
+ RETURN VALUES\r
+ This function does not return a value.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> IOCTL <a href="./cl_obj_h.html#robo18">Object</a>, <a href="#robo347">cl_ioctl_handle_t</a>, <a href="#robo352">cl_ioctl_process</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo346">[Functions]<a name="Component20Library3a20IOCTL20Object2fcl5fioctl5fctl5fcode">\r
+Component Library: IOCTL Object/cl_ioctl_ctl_code</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_ioctl_ctl_code</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> Returns the 32-bit control code of an IOCTL\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT uint32_t CL_API\r
+<strong>cl_ioctl_ctl_code</strong>(\r
+ IN <a href="#robo347">cl_ioctl_handle_t</a> h_ioctl );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> h_ioctl\r
+ [in] Handle to an IOCTL\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> Returns the 32-bit control code of the specified IOCTL request,\r
+ as defined using the IOCTL_CMD macro.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> The <strong>cl_ioctl_ctl_code</strong> function is only available in the kernel.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> IOCTL <a href="./cl_obj_h.html#robo18">Object</a>, <a href="#robo347">cl_ioctl_handle_t</a>, <a href="#robo355">cl_ioctl_type</a>, <a href="#robo344">cl_ioctl_cmd</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo347">[Definitions]<a name="Component20Library3a20IOCTL20Object2fcl5fioctl5fhandle5ft">\r
+Component Library: IOCTL Object/cl_ioctl_handle_t</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_definitions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_ioctl_handle_t</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> Opaque handle representing an IO request.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> The <strong>cl_ioctl_handle_t</strong> type is only available in the kernel.\r
+ The <strong>cl_ioctl_handle_t</strong> type should be treated as opaque, as it\r
+ varies from environment to environment.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> IOCTL <a href="./cl_obj_h.html#robo18">Object</a>, <a href="#robo355">cl_ioctl_type</a>, <a href="#robo344">cl_ioctl_cmd</a>, <a href="#robo348">cl_ioctl_in_buf</a>,\r
+ <a href="#robo349">cl_ioctl_in_size</a>, <a href="#robo350">cl_ioctl_out_buf</a>, <a href="#robo351">cl_ioctl_out_size</a>,\r
+ cl_ioctl_set_status, cl_ioctl_set_ret_bytes\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo348">[Functions]<a name="Component20Library3a20IOCTL20Object2fcl5fioctl5fin5fbuf">\r
+Component Library: IOCTL Object/cl_ioctl_in_buf</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_ioctl_in_buf</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> Returns a pointer to the input buffer of an IOCTL.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT void* CL_API\r
+<strong>cl_ioctl_in_buf</strong>(\r
+ IN <a href="#robo347">cl_ioctl_handle_t</a> h_ioctl );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> h_ioctl\r
+ [in] Handle to an IOCTL\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> Returns the input buffer of the specified IOCTL request.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> The <strong>cl_ioctl_in_buf</strong> function is only available in the kernel.\r
+\r
+ In Windows, for IOCTL operations defined as METHOD_IN_DIRECT, the\r
+ returned pointer points to the MDL describing the input buffer.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> IOCTL <a href="./cl_obj_h.html#robo18">Object</a>, <a href="#robo347">cl_ioctl_handle_t</a>, <a href="#robo349">cl_ioctl_in_size</a>,\r
+ <a href="#robo350">cl_ioctl_out_buf</a>, <a href="#robo351">cl_ioctl_out_size</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo349">[Functions]<a name="Component20Library3a20IOCTL20Object2fcl5fioctl5fin5fsize">\r
+Component Library: IOCTL Object/cl_ioctl_in_size</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_ioctl_in_size</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> Returns the size of the input buffer of an IOCTL.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT size_t CL_API\r
+<strong>cl_ioctl_in_size</strong>(\r
+ IN <a href="#robo347">cl_ioctl_handle_t</a> h_ioctl );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> h_ioctl\r
+ [in] Handle to an IOCTL\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> Returns the size, in bytes, of the input buffer of the specified\r
+ IOCTL request.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> The <strong>cl_ioctl_in_size</strong> function is only available in the kernel.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> IOCTL <a href="./cl_obj_h.html#robo18">Object</a>, <a href="#robo347">cl_ioctl_handle_t</a>, <a href="#robo348">cl_ioctl_in_buf</a>,\r
+ <a href="#robo350">cl_ioctl_out_buf</a>, <a href="#robo351">cl_ioctl_out_size</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo350">[Functions]<a name="Component20Library3a20IOCTL20Object2fcl5fioctl5fout5fbuf">\r
+Component Library: IOCTL Object/cl_ioctl_out_buf</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_ioctl_out_buf</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> Returns a pointer to the output buffer of an IOCTL.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT void* CL_API\r
+<strong>cl_ioctl_out_buf</strong>(\r
+ IN <a href="#robo347">cl_ioctl_handle_t</a> h_ioctl );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> h_ioctl\r
+ [in] Handle to an IOCTL\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> Returns a pointer to the output buffer of the specified IOCTL request.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> The <strong>cl_ioctl_out_buf</strong> function is only available in the kernel.\r
+\r
+ In Windows, for IOCTL operations defined as METHOD_IN_DIRECT or\r
+ METHOD_OUT_DIRECT, the returned pointer points to the MDL describing\r
+ the input buffer.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> IOCTL <a href="./cl_obj_h.html#robo18">Object</a>, <a href="#robo347">cl_ioctl_handle_t</a>, <a href="#robo351">cl_ioctl_out_size</a>,\r
+ <a href="#robo348">cl_ioctl_in_buf</a>, <a href="#robo349">cl_ioctl_in_size</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo351">[Functions]<a name="Component20Library3a20IOCTL20Object2fcl5fioctl5fout5fsize">\r
+Component Library: IOCTL Object/cl_ioctl_out_size</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_ioctl_out_size</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> Returns the size of the output buffer of an IOCTL.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT size_t CL_API\r
+<strong>cl_ioctl_out_size</strong>(\r
+ IN <a href="#robo347">cl_ioctl_handle_t</a> h_ioctl );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> h_ioctl\r
+ [in] Handle to an IOCTL\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> Returns the size, in bytes, of the input buffer of the specified\r
+ IOCTL request.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> The <strong>cl_ioctl_out_size</strong> function is only available in the kernel.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> IOCTL <a href="./cl_obj_h.html#robo18">Object</a>, <a href="#robo347">cl_ioctl_handle_t</a>, <a href="#robo350">cl_ioctl_out_buf</a>,\r
+ <a href="#robo348">cl_ioctl_in_buf</a>, <a href="#robo349">cl_ioctl_in_size</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo352">[Functions]<a name="Component20Library3a20IOCTL20Object2fcl5fioctl5fprocess">\r
+Component Library: IOCTL Object/cl_ioctl_process</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_ioctl_process</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_ioctl_process</strong> function unpacks information initiated by a call to\r
+ <a href="#robo353">cl_ioctl_request</a> function and invokes a user-supplied callback.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT <a href="./cl_types_h.html#robo304">cl_status_t</a> CL_API\r
+<strong>cl_ioctl_process</strong>(\r
+ IN void *p_ioctl,\r
+ IN <a href="#robo356">cl_pfn_ioctl_handler_t</a> pfn_ioctl_handler,\r
+ IN void *context_1,\r
+ IN void *context_2 );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_ioctl\r
+ [in] Pointer to an OS specific IOCTL information. In Linux,\r
+ this parameter depends on whether the IOCTL is handled synchronously\r
+ or asynchronously. See the notes for further detail.\r
+ In Windows, this is a pointer to an IRP.\r
+\r
+ pfn_ioctl_handler\r
+ [in] Pointer to the callback function to invoke for handling the IOCTL.\r
+ This callback is independent of the IOCTL command.\r
+\r
+ context_1\r
+ [in] First of two context parameters to pass to the handler.\r
+\r
+ context_2\r
+ [in] Second of two context parameters to pass to the handler.\r
+\r
+ RETURN VALUES\r
+ CL_SUCCESS if the IOCTL was processed successfully.\r
+\r
+ Other values to indicate various failures.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> Users must call <a href="#robo345">cl_ioctl_complete</a> from within the handler if completing\r
+ the IOCTL request synchronously. If the IOCTL request's control code is\r
+ invalid, the handler should return CL_INVALID_REQUEST.\r
+\r
+ In Linux, the p_ioctl parameter is a copy of the argp parameter on input,\r
+ and on output points to the IOCTL request object passed to the IOCTL\r
+ handler if and only if the IOCTL handler returned CL_PENDING.\r
+ This allows the user to cancel the request by passing the same\r
+ handle to the cancel routine that was passed to the IOCTL handler.\r
+ If all IOCTLs are handled synchronously, it is acceptable to pass the argp\r
+ parameter of the IOCTL entry point instead of a copy.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> IOCTL <a href="./cl_obj_h.html#robo18">Object</a>, <a href="#robo347">cl_ioctl_handle_t</a>, <a href="#robo356">cl_pfn_ioctl_handler_t</a>, <a href="#robo345">cl_ioctl_complete</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo353">[Functions]<a name="Component20Library3a20IOCTL20Object2fcl5fioctl5frequest">\r
+Component Library: IOCTL Object/cl_ioctl_request</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_ioctl_request</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_ioctl_request</strong> is used by user-mode clients to initiate IOCTL\r
+ requests to a device.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT <a href="./cl_types_h.html#robo304">cl_status_t</a> CL_API\r
+<strong>cl_ioctl_request</strong>(\r
+ IN void *h_dev,\r
+ IN uint32_t ioctl_code,\r
+ IN void *p_in_buf,\r
+ IN size_t in_size,\r
+ OUT void *p_out_buf,\r
+ IN size_t out_size,\r
+ OUT size_t *p_ret_bytes OPTIONAL,\r
+ IN void *p_async_info OPTIONAL );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> h_dev\r
+ [in] Handle to the device to which the IOCTL request is targetted.\r
+ In Linux, this is a file descriptor. In Windows, this is a file\r
+ handle.\r
+\r
+ ioctl_code\r
+ [in] Control code for the IOCTL request.\r
+\r
+ p_in_buf\r
+ [in] Pointer to the input buffer.\r
+\r
+ in_size\r
+ [in] Size, in bytes, of the input buffer.\r
+\r
+ p_out_buf\r
+ [out] Pointer to the output buffer.\r
+\r
+ out_size\r
+ [in] Size, in bytes, of the output buffer.\r
+\r
+ p_ret_bytes\r
+ [out] Number of bytes written to the output buffer. This parameter is\r
+ mutually exclusive of the p_async_info parameter.\r
+\r
+ p_async_info\r
+ [in] For platforms that support asynchronous I/O, supplies a pointer\r
+ to that platform's async I/O structure, if any. For Windows, this\r
+ is a pointer to an OVERLAPPED structure. This parameter is mutually\r
+ exclusive of the p_ret_bytes parameter.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> IOCTL <a href="./cl_obj_h.html#robo18">Object</a>, <a href="#robo354">cl_ioctl_result</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo354">[Functions]<a name="Component20Library3a20IOCTL20Object2fcl5fioctl5fresult">\r
+Component Library: IOCTL Object/cl_ioctl_result</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_ioctl_result</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> Checks the status of an asynchronous IOCTL request.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT <a href="./cl_types_h.html#robo304">cl_status_t</a> CL_API\r
+<strong>cl_ioctl_result</strong>(\r
+ IN void *h_dev,\r
+ IN void *p_async_info,\r
+ OUT size_t *p_ret_bytes,\r
+ IN boolean_t blocking );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> h_dev\r
+ [in] Handle to the device to which the IOCTL request is targetted.\r
+ In Linux, this is a file descriptor. In Windows, this is a file\r
+ handle.\r
+\r
+ p_async_info\r
+ [in] For platforms that support asynchronous I/O, supplies a pointer\r
+ to that platform's async I/O structure, if any. For Windows, this\r
+ is a pointer to an OVERLAPPED structure. This must be the same\r
+ as that provided in the <a href="#robo353">cl_ioctl_request</a> function.\r
+\r
+ p_ret_bytes\r
+ [out] Number of bytes written to the output buffer.\r
+\r
+ blocking\r
+ [in] If TRUE, indicates that the call should wait until the\r
+ specified IOCTL request is complete.\r
+\r
+ RETURN VALUES\r
+ CL_SUCCESS if the IOCTL request was successful. p_ret_bytes contains\r
+ the number bytes written to the output buffer.\r
+\r
+ CL_PENDING if the IOCTL request is not yet complete.\r
+\r
+ Other status values to indicate errors.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> IOCTL <a href="./cl_obj_h.html#robo18">Object</a>, <a href="#robo353">cl_ioctl_request</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo355">[Functions]<a name="Component20Library3a20IOCTL20Object2fcl5fioctl5ftype">\r
+Component Library: IOCTL Object/cl_ioctl_type</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_ioctl_type</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> Returns the type of an IOCTL.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT uint16_t CL_API\r
+<strong>cl_ioctl_type</strong>(\r
+ IN <a href="#robo347">cl_ioctl_handle_t</a> h_ioctl );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> h_ioctl\r
+ [in] Handle to an IOCTL\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> Returns the type of the specified IOCTL request, as defined using\r
+ the IOCTL_CMD macro.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> The <strong>cl_ioctl_type</strong> function is only available in the kernel.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> IOCTL <a href="./cl_obj_h.html#robo18">Object</a>, <a href="#robo347">cl_ioctl_handle_t</a>, <a href="#robo344">cl_ioctl_cmd</a>, <a href="#robo346">cl_ioctl_ctl_code</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo356">[Definitions]<a name="Component20Library3a20IOCTL20Object2fcl5fpfn5fioctl5fhandler5ft">\r
+Component Library: IOCTL Object/cl_pfn_ioctl_handler_t</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_definitions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_pfn_ioctl_handler_t</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_pfn_ioctl_handler_t</strong> function type defines the prototype for\r
+ IOCTL handlers used when handling IOCTL requests initiated by\r
+ <a href="#robo353">cl_ioctl_request</a>.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>typedef <a href="./cl_types_h.html#robo304">cl_status_t</a>\r
+(CL_API *<strong>cl_pfn_ioctl_handler_t</strong>)(\r
+ IN <a href="#robo347">cl_ioctl_handle_t</a> h_ioctl,\r
+ IN void *context_1,\r
+ IN void *context_2 );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> h_ioctl\r
+ [in] Handle to the IOCTL request.\r
+\r
+ context_1\r
+ [in] First context parameters, as provided to <a href="#robo352">cl_ioctl_process</a>.\r
+\r
+ context_2\r
+ [in] Second context parameters, as provided to <a href="#robo352">cl_ioctl_process</a>.\r
+\r
+ RETURN VALUES\r
+ CL_SUCCESS if the IOCTL was completed successfully.\r
+\r
+ CL_PENDING if the IOCTL is being processed asynchronously.\r
+\r
+ Other return values in case of errors.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> It is acceptable to complete the IOCTL successfully to report an error\r
+ status in the output buffer.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> IOCTL <a href="./cl_obj_h.html#robo18">Object</a>, <a href="#robo347">cl_ioctl_handle_t</a>, <a href="#robo352">cl_ioctl_process</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo357">[Definitions]<a name="Component20Library3a20IOCTL20Object2fIOCTL5fCODE">\r
+Component Library: IOCTL Object/IOCTL_CODE</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_definitions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>IOCTL_CODE</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> Macro for defining IO control command codes.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>* uint32_t <strong>IOCTL_CODE</strong>( uint16_t type, uint16_t cmd )\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> type\r
+ [in] user-defined type representing the type of command. For Linux,\r
+ the type is truncated to 8-bits. For Windows, the type is a 16-bit\r
+ value, as described in "Specifying Device Types" in the DDK docs.\r
+\r
+ cmd\r
+ [in] User-defined command. For Linux, the command field is truncated\r
+ to 8-bits. For Windows, the command can be 12-bits, with values\r
+ below 0x800 reserved by Microsoft for system defined commands.\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> A 32-bit control code. User-mode clients use the control code to initiate\r
+ requests. Kernel-mode clients use the control code to distinguish between\r
+ different requests.\r
+</pre>\r
+</span><p><strong>NOTE</strong></p>\r
+<span class="NOTE"><pre> In Windows, all IOCTL command codes defined with the <strong>IOCTL_CODE</strong> command\r
+ result in FILE_ANY_ACCESS and METHOD_BUFFERED being specified.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> IOCTL <a href="./cl_obj_h.html#robo18">Object</a>, cl_dev_ioctl, <a href="#robo355">cl_ioctl_type</a>, <a href="#robo344">cl_ioctl_cmd</a>\r
+</pre>\r
+</span>\r
+</body>\r
+</html>\r
--- /dev/null
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">\r
+<html>\r
+<head>\r
+<link rel="stylesheet" href="../robodoc.css" type="text/css">\r
+<title>./inc_doc/complib/cl_irqlock_h.html</title>\r
+<!-- Source: ./inc/complib/cl_irqlock.h -->\r
+<!-- Generated with ROBODoc Version 4.99.22 (Mar 6 2006) -->\r
+</head>\r
+<body bgcolor="#FFFFFF">\r
+<a name="robo_top_of_doc">Generated from ./inc/complib/cl_irqlock.h</a> with <a href="http://sourceforge.net/projects/robodoc/">ROBODoc</a> v4.99.22 on Sun Apr 16 2006 17:39:25\r
+<br />\r
+<hr />\r
+\r
+<h2><a name="robo14">[Modules]<a name="Component20Library2fIrqlock">\r
+Component Library/Irqlock</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_modules.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>Irqlock</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> <strong>Irqlock</strong> provides synchronization at interrupt level between threads for \r
+ exclusive access to a resource.\r
+\r
+ The irqlock functions manipulate a cl_irqlock_t structure which should \r
+ be treated as opaque and should be manipulated only through the provided \r
+ functions.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Structures:\r
+ cl_irqlock_t\r
+\r
+ Initialization:\r
+ <a href="#robo359">cl_irqlock_construct</a>, <a href="#robo361">cl_irqlock_init</a>, <a href="#robo360">cl_irqlock_destroy</a>\r
+\r
+ Manipulation\r
+ <a href="#robo358">cl_irqlock_acquire</a>, <a href="#robo362">cl_irqlock_release</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo358">[Functions]<a name="Component20Library3a20Irqlock2fcl5firqlock5facquire">\r
+Component Library: Irqlock/cl_irqlock_acquire</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_irqlock_acquire</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_irqlock_acquire</strong> function acquires a IRQ lock.\r
+ This version of lock does not prevent an interrupt from \r
+ occuring on the processor on which the code is being\r
+ executed. To protect from an interrupt level resource\r
+ use the cl_irqlock_acquire_irq function.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT void CL_API\r
+<strong>cl_irqlock_acquire</strong>( \r
+ IN cl_irqlock_t* const p_irqlock );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_irqlock \r
+ [in] Pointer to a IRQ lock structure to acquire.\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> This function does not return a value.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> <a href="#robo14">Irqlock</a>, <a href="#robo362">cl_irqlock_release</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo359">[Functions]<a name="Component20Library3a20Irqlock2fcl5firqlock5fconstruct">\r
+Component Library: Irqlock/cl_irqlock_construct</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_irqlock_construct</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_irqlock_construct</strong> function initializes the state of a \r
+ IRQ lock.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT void CL_API\r
+<strong>cl_irqlock_construct</strong>( \r
+ IN cl_irqlock_t* const p_irqlock );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_irqlock \r
+ [in] Pointer to a IRQ lock structure whose state to initialize.\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> This function does not return a value.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> Allows calling <a href="#robo360">cl_irqlock_destroy</a> without first calling \r
+ <a href="#robo361">cl_irqlock_init</a>.\r
+\r
+ Calling <strong>cl_irqlock_construct</strong> is a prerequisite to calling any other\r
+ IRQ lock function except <a href="#robo361">cl_irqlock_init</a>.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> <a href="#robo14">Irqlock</a>, <a href="#robo361">cl_irqlock_init</a>, <a href="#robo360">cl_irqlock_destroy</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo360">[Functions]<a name="Component20Library3a20Irqlock2fcl5firqlock5fdestroy">\r
+Component Library: Irqlock/cl_irqlock_destroy</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_irqlock_destroy</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_irqlock_destroy</strong> function performs all necessary cleanup of a \r
+ IRQ lock.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT void CL_API\r
+<strong>cl_irqlock_destroy</strong>( \r
+ IN cl_irqlock_t* const p_irqlock );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_irqlock \r
+ [in] Pointer to a IRQ lock structure to destroy.\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> This function does not return a value.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> Performs any necessary cleanup of a IRQ lock. This function must only \r
+ be called if either <a href="#robo359">cl_irqlock_construct</a> or <a href="#robo361">cl_irqlock_init</a> has been \r
+ called.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> <a href="#robo14">Irqlock</a>, <a href="#robo359">cl_irqlock_construct</a>, <a href="#robo361">cl_irqlock_init</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo361">[Functions]<a name="Component20Library3a20Irqlock2fcl5firqlock5finit">\r
+Component Library: Irqlock/cl_irqlock_init</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_irqlock_init</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_irqlock_init</strong> function initializes a IRQ lock for use.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT <a href="./cl_types_h.html#robo304">cl_status_t</a> CL_API\r
+<strong>cl_irqlock_init</strong>( \r
+ IN cl_irqlock_t* const p_irqlock,\r
+ IN cl_interrupt_t* const p_interrupt );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_irqlock \r
+ [in] Pointer to a IRQ lock structure to initialize.\r
+\r
+ p_interrupt\r
+ [in] Platform specific pointer conveying information about the\r
+ interrupt vector and level with which to synchronize.\r
+\r
+ RETURN VALUES\r
+ CL_SUCCESS if initialization succeeded.\r
+\r
+ CL_ERROR if initialization failed. Callers should call \r
+ <a href="#robo360">cl_irqlock_destroy</a> to clean up any resources allocated during \r
+ initialization.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> Initialize the IRQ lock structure. Allows calling cl_irqlock_aquire \r
+ and <a href="#robo362">cl_irqlock_release</a>.\r
+\r
+ In Linux, the p_interrupt parameter is currently ignored.\r
+\r
+ In Windows, the p_interrupt parameter is a pointer to a KINTERRUPT object,\r
+ the value of which is supplied by a call to IoConnectInterrupt.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> <a href="#robo14">Irqlock</a>, <a href="#robo359">cl_irqlock_construct</a>, <a href="#robo360">cl_irqlock_destroy</a>, \r
+ <a href="#robo358">cl_irqlock_acquire</a>, <a href="#robo362">cl_irqlock_release</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo362">[Functions]<a name="Component20Library3a20Irqlock2fcl5firqlock5frelease">\r
+Component Library: Irqlock/cl_irqlock_release</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_irqlock_release</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_irqlock_release</strong> function releases a IRQ lock object.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT void CL_API\r
+<strong>cl_irqlock_release</strong>(\r
+ IN cl_irqlock_t* const p_irqlock );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_irqlock \r
+ [in] Pointer to a IRQ lock structure to release.\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> This function does not return a value.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> Releases a IRQ lock after a call to <a href="#robo358">cl_irqlock_acquire</a>.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> <a href="#robo14">Irqlock</a>, <a href="#robo358">cl_irqlock_acquire</a>\r
+</pre>\r
+</span>\r
+</body>\r
+</html>\r
--- /dev/null
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">\r
+<html>\r
+<head>\r
+<link rel="stylesheet" href="../robodoc.css" type="text/css">\r
+<title>./inc_doc/complib/cl_list_h.html</title>\r
+<!-- Source: ./inc/complib/cl_list.h -->\r
+<!-- Generated with ROBODoc Version 4.99.22 (Mar 6 2006) -->\r
+</head>\r
+<body bgcolor="#FFFFFF">\r
+<a name="robo_top_of_doc">Generated from ./inc/complib/cl_list.h</a> with <a href="http://sourceforge.net/projects/robodoc/">ROBODoc</a> v4.99.22 on Sun Apr 16 2006 17:39:25\r
+<br />\r
+<hr />\r
+\r
+<h2><a name="robo15">[Modules]<a name="Component20Library2fList">\r
+Component Library/List</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_modules.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>List</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> <strong>List</strong> stores objects in a doubly linked list.\r
+\r
+ Unlike quick list, users pass pointers to the object being stored, rather\r
+ than to a <a href="./cl_qlist_h.html#robo554">cl_list_item_t</a> structure. Insertion operations on a list can\r
+ fail, and callers should trap for such failures.\r
+\r
+ Use quick list in situations where insertion failures cannot be tolerated.\r
+\r
+ <strong>List</strong> is not thread safe, and users must provide serialization.\r
+\r
+ The list functions operates on a <a href="#robo390">cl_list_t</a> structure which should be\r
+ treated as opaque and should be manipulated only through the provided\r
+ functions.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Types:\r
+ <a href="#robo381">cl_list_iterator_t</a>\r
+\r
+ Structures:\r
+ <a href="#robo390">cl_list_t</a>\r
+\r
+ Callbacks:\r
+ <a href="#robo392">cl_pfn_list_apply_t</a>, <a href="#robo393">cl_pfn_list_find_t</a>\r
+\r
+ Initialization/Destruction:\r
+ <a href="#robo367">cl_list_construct</a>, <a href="#robo374">cl_list_init</a>, <a href="#robo369">cl_list_destroy</a>\r
+\r
+ Iteration:\r
+ <a href="#robo382">cl_list_next</a>, <a href="#robo384">cl_list_prev</a>, <a href="#robo373">cl_list_head</a>, <a href="#robo391">cl_list_tail</a>,\r
+ <a href="#robo370">cl_list_end</a>\r
+\r
+ Manipulation:\r
+ <a href="#robo377">cl_list_insert_head</a>, <a href="#robo380">cl_list_insert_tail</a>,\r
+ <a href="#robo375">cl_list_insert_array_head</a>, <a href="#robo376">cl_list_insert_array_tail</a>,\r
+ <a href="#robo379">cl_list_insert_prev</a>, <a href="#robo378">cl_list_insert_next</a>,\r
+ <a href="#robo386">cl_list_remove_head</a>, <a href="#robo389">cl_list_remove_tail</a>,\r
+ <a href="#robo388">cl_list_remove_object</a>, <a href="#robo387">cl_list_remove_item</a>, <a href="#robo385">cl_list_remove_all</a>\r
+\r
+ Search:\r
+ <a href="#robo365">cl_is_object_in_list</a>, <a href="#robo371">cl_list_find_from_head</a>, <a href="#robo372">cl_list_find_from_tail</a>,\r
+ <a href="#robo366">cl_list_apply_func</a>\r
+\r
+ Attributes:\r
+ <a href="#robo368">cl_list_count</a>, <a href="#robo363">cl_is_list_empty</a>, <a href="#robo364">cl_is_list_inited</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo363">[Functions]<a name="Component20Library3a20List2fcl5fis5flist5fempty">\r
+Component Library: List/cl_is_list_empty</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_is_list_empty</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_is_list_empty</strong> function returns whether a list is empty.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_INLINE boolean_t CL_API\r
+<strong>cl_is_list_empty</strong>(\r
+ IN const <a href="#robo390">cl_list_t</a>* const p_list )\r
+{\r
+ CL_ASSERT( p_list );\r
+ CL_ASSERT( <a href="./cl_qpool_h.html#robo615">cl_is_qpool_inited</a>( &p_list->list_item_pool ) );\r
+ return( <a href="./cl_qlist_h.html#robo553">cl_is_qlist_empty</a>( &p_list->list ) );\r
+}\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_list\r
+ [in] Pointer to a <a href="#robo390">cl_list_t</a> structure.\r
+\r
+ RETURN VALUES\r
+ TRUE if the specified list is empty.\r
+\r
+ FALSE otherwise.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> <a href="#robo15">List</a>, <a href="#robo368">cl_list_count</a>, <a href="#robo385">cl_list_remove_all</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo364">[Functions]<a name="Component20Library3a20List2fcl5fis5flist5finited">\r
+Component Library: List/cl_is_list_inited</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_is_list_inited</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_is_list_inited</strong> function returns whether a list was\r
+ initialized successfully.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_INLINE boolean_t CL_API\r
+<strong>cl_is_list_inited</strong>(\r
+ IN const <a href="#robo390">cl_list_t</a>* const p_list )\r
+{\r
+ /* CL_ASSERT that a non-null pointer is provided. */\r
+ CL_ASSERT( p_list );\r
+ /*\r
+ * The pool is the last thing initialized. If it is initialized, the\r
+ * list is initialized too.\r
+ */\r
+ return( <a href="./cl_qpool_h.html#robo615">cl_is_qpool_inited</a>( &p_list->list_item_pool ) );\r
+}\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_list\r
+ [in] Pointer to a <a href="#robo390">cl_list_t</a> structure whose initilization state\r
+ to check.\r
+\r
+ RETURN VALUES\r
+ TRUE if the list was initialized successfully.\r
+\r
+ FALSE otherwise.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> Allows checking the state of a list to determine if invoking\r
+ member functions is appropriate.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> <a href="#robo15">List</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo365">[Functions]<a name="Component20Library3a20List2fcl5fis5fobject5fin5flist">\r
+Component Library: List/cl_is_object_in_list</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_is_object_in_list</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_is_object_in_list</strong> function returns whether an object\r
+ is stored in a list.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT boolean_t CL_API\r
+<strong>cl_is_object_in_list</strong>(\r
+ IN const <a href="#robo390">cl_list_t</a>* const p_list,\r
+ IN const void* const p_object );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_list\r
+ [in] Pointer to a <a href="#robo390">cl_list_t</a> structure in which to look for the object.\r
+\r
+ p_object\r
+ [in] Pointer to an object stored in a list.\r
+\r
+ RETURN VALUES\r
+ TRUE if p_object was found in the list.\r
+\r
+ FALSE otherwise.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> <a href="#robo15">List</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo366">[Functions]<a name="Component20Library3a20List2fcl5flist5fapply5ffunc">\r
+Component Library: List/cl_list_apply_func</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_list_apply_func</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_list_apply_func</strong> function executes a specified function for every\r
+ object stored in a list.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT void CL_API\r
+<strong>cl_list_apply_func</strong>(\r
+ IN const <a href="#robo390">cl_list_t</a>* const p_list,\r
+ IN <a href="#robo392">cl_pfn_list_apply_t</a> pfn_func,\r
+ IN const void* const context );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_list\r
+ [in] Pointer to a <a href="#robo390">cl_list_t</a> structure to iterate.\r
+\r
+ pfn_func\r
+ [in] Function invoked for every item in a list.\r
+ See the <a href="#robo392">cl_pfn_list_apply_t</a> function type declaration for details\r
+ about the callback function.\r
+\r
+ context\r
+ [in] Value to pass to the callback functions to provide context.\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> This function does not return a value.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> <strong>cl_list_apply_func</strong> invokes the specified callback function for every\r
+ object stored in the list, starting from the head. The function specified\r
+ by the pfn_func parameter must not perform any list operations as these\r
+ would corrupt the list.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> <a href="#robo15">List</a>, <a href="#robo371">cl_list_find_from_head</a>, <a href="#robo372">cl_list_find_from_tail</a>,\r
+ <a href="#robo392">cl_pfn_list_apply_t</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo367">[Functions]<a name="Component20Library3a20List2fcl5flist5fconstruct">\r
+Component Library: List/cl_list_construct</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_list_construct</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_list_construct</strong> function constructs a list.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT void CL_API\r
+<strong>cl_list_construct</strong>(\r
+ IN <a href="#robo390">cl_list_t</a>* const p_list );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_list\r
+ [in] Pointer to <a href="#robo390">cl_list_t</a> object whose state to initialize.\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> This function does not return a value.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> Allows calling <a href="#robo374">cl_list_init</a>, <a href="#robo369">cl_list_destroy</a> and <a href="#robo364">cl_is_list_inited</a>.\r
+\r
+ Calling <strong>cl_list_construct</strong> is a prerequisite to calling any other\r
+ list function except <a href="#robo374">cl_list_init</a>.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> <a href="#robo15">List</a>, <a href="#robo374">cl_list_init</a>, <a href="#robo369">cl_list_destroy</a>, <a href="#robo364">cl_is_list_inited</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo368">[Functions]<a name="Component20Library3a20List2fcl5flist5fcount">\r
+Component Library: List/cl_list_count</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_list_count</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_list_count</strong> function returns the number of objects stored in a list.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_INLINE size_t CL_API\r
+<strong>cl_list_count</strong>(\r
+ IN const <a href="#robo390">cl_list_t</a>* const p_list )\r
+{\r
+ CL_ASSERT( p_list );\r
+ CL_ASSERT( <a href="./cl_qpool_h.html#robo615">cl_is_qpool_inited</a>( &p_list->list_item_pool ) );\r
+\r
+ return( <a href="./cl_qlist_h.html#robo559">cl_qlist_count</a>( &p_list->list ) );\r
+}\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_list\r
+ [in] Pointer to a <a href="#robo390">cl_list_t</a> structure whose object to count.\r
+\r
+ RETURN VALUES\r
+ Number of objects stored in the specified list.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> <a href="#robo15">List</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo369">[Functions]<a name="Component20Library3a20List2fcl5flist5fdestroy">\r
+Component Library: List/cl_list_destroy</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_list_destroy</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_list_destroy</strong> function destroys a list.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT void CL_API\r
+<strong>cl_list_destroy</strong>(\r
+ IN <a href="#robo390">cl_list_t</a>* const p_list );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_list\r
+ [in] Pointer to <a href="#robo390">cl_list_t</a> structure to destroy.\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> This function does not return a value.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> <strong>cl_list_destroy</strong> does not affect any of the objects stored in the list,\r
+ but does release all memory allocated internally. Further operations\r
+ should not be attempted on the list after <strong>cl_list_destroy</strong> is invoked.\r
+\r
+ This function should only be called after a call to <a href="#robo367">cl_list_construct</a>\r
+ or <a href="#robo374">cl_list_init</a>.\r
+\r
+ In debug builds, <strong>cl_list_destroy</strong> asserts if the list is not empty.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> <a href="#robo15">List</a>, <a href="#robo367">cl_list_construct</a>, <a href="#robo374">cl_list_init</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo370">[Functions]<a name="Component20Library3a20List2fcl5flist5fend">\r
+Component Library: List/cl_list_end</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_list_end</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_list_end</strong> function returns returns the list iterator for\r
+ the end of a list.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_INLINE const <a href="#robo381">cl_list_iterator_t</a> CL_API\r
+<strong>cl_list_end</strong>(\r
+ IN const <a href="#robo390">cl_list_t</a>* const p_list )\r
+{\r
+ CL_ASSERT( p_list );\r
+ CL_ASSERT( <a href="./cl_qpool_h.html#robo615">cl_is_qpool_inited</a>( &p_list->list_item_pool ) );\r
+\r
+ return( <a href="./cl_qlist_h.html#robo560">cl_qlist_end</a>( &p_list->list ) );\r
+}\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_list\r
+ [in] Pointer to a <a href="#robo390">cl_list_t</a> structure for which the iterator for the\r
+ object at the head is to be returned.\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> <a href="#robo381">cl_list_iterator_t</a> for the end of the list.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> Use <a href="#robo383">cl_list_obj</a> to retrieve the object associated with the\r
+ returned <a href="#robo381">cl_list_iterator_t</a>.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> <a href="#robo15">List</a>, <a href="#robo373">cl_list_head</a>, <a href="#robo391">cl_list_tail</a>, <a href="#robo382">cl_list_next</a>, <a href="#robo384">cl_list_prev</a>,\r
+ <a href="#robo383">cl_list_obj</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo371">[Functions]<a name="Component20Library3a20List2fcl5flist5ffind5ffrom5fhead">\r
+Component Library: List/cl_list_find_from_head</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_list_find_from_head</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_list_find_from_head</strong> function uses a specified function\r
+ to search for an object starting from the head of a list.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT const <a href="#robo381">cl_list_iterator_t</a> CL_API\r
+<strong>cl_list_find_from_head</strong>(\r
+ IN const <a href="#robo390">cl_list_t</a>* const p_list,\r
+ IN <a href="#robo393">cl_pfn_list_find_t</a> pfn_func,\r
+ IN const void* const context );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_list\r
+ [in] Pointer to a <a href="#robo390">cl_list_t</a> structure to search.\r
+\r
+ pfn_func\r
+ [in] Function invoked to determine if a match was found.\r
+ See the <a href="#robo393">cl_pfn_list_find_t</a> function type declaration for details\r
+ about the callback function.\r
+\r
+ context\r
+ [in] Value to pass to the callback functions to provide context.\r
+\r
+ RETURN VALUES\r
+ Returns the iterator for the object if found.\r
+\r
+ Returns the iterator for the list end otherwise.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> <strong>cl_list_find_from_head</strong> does not remove the found object from\r
+ the list. The iterator for the object is returned when the function\r
+ provided by the pfn_func parameter returns CL_SUCCESS. The function\r
+ specified by the pfn_func parameter must not perform any list\r
+ operations as these would corrupt the list.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> <a href="#robo15">List</a>, <a href="#robo372">cl_list_find_from_tail</a>, <a href="#robo366">cl_list_apply_func</a>,\r
+ <a href="#robo393">cl_pfn_list_find_t</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo372">[Functions]<a name="Component20Library3a20List2fcl5flist5ffind5ffrom5ftail">\r
+Component Library: List/cl_list_find_from_tail</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_list_find_from_tail</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_list_find_from_tail</strong> function uses a specified function\r
+ to search for an object starting from the tail of a list.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT const <a href="#robo381">cl_list_iterator_t</a> CL_API\r
+<strong>cl_list_find_from_tail</strong>(\r
+ IN const <a href="#robo390">cl_list_t</a>* const p_list,\r
+ IN <a href="#robo393">cl_pfn_list_find_t</a> pfn_func,\r
+ IN const void* const context );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_list\r
+ [in] Pointer to a <a href="#robo390">cl_list_t</a> structure to search.\r
+\r
+ pfn_func\r
+ [in] Function invoked to determine if a match was found.\r
+ See the <a href="#robo393">cl_pfn_list_find_t</a> function type declaration for details\r
+ about the callback function.\r
+\r
+ context\r
+ [in] Value to pass to the callback functions to provide context.\r
+\r
+ RETURN VALUES\r
+ Returns the iterator for the object if found.\r
+\r
+ Returns the iterator for the list end otherwise.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> <strong>cl_list_find_from_tail</strong> does not remove the found object from\r
+ the list. The iterator for the object is returned when the function\r
+ provided by the pfn_func parameter returns CL_SUCCESS. The function\r
+ specified by the pfn_func parameter must not perform any list\r
+ operations as these would corrupt the list.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> <a href="#robo15">List</a>, <a href="#robo371">cl_list_find_from_head</a>, <a href="#robo366">cl_list_apply_func</a>,\r
+ <a href="#robo393">cl_pfn_list_find_t</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo373">[Functions]<a name="Component20Library3a20List2fcl5flist5fhead">\r
+Component Library: List/cl_list_head</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_list_head</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_list_head</strong> function returns returns a list iterator for\r
+ the head of a list.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_INLINE const <a href="#robo381">cl_list_iterator_t</a> CL_API\r
+<strong>cl_list_head</strong>(\r
+ IN const <a href="#robo390">cl_list_t</a>* const p_list )\r
+{\r
+ CL_ASSERT( p_list );\r
+ CL_ASSERT( <a href="./cl_qpool_h.html#robo615">cl_is_qpool_inited</a>( &p_list->list_item_pool ) );\r
+\r
+ return( <a href="./cl_qlist_h.html#robo565">cl_qlist_head</a>( &p_list->list ) );\r
+}\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_list\r
+ [in] Pointer to a <a href="#robo390">cl_list_t</a> structure for which the iterator for the\r
+ object at the head is to be returned.\r
+\r
+ RETURN VALUES\r
+ <a href="#robo381">cl_list_iterator_t</a> for the head of the list.\r
+\r
+ <a href="#robo381">cl_list_iterator_t</a> for the end of the list if the list is empty.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> Use <a href="#robo383">cl_list_obj</a> to retrieve the object associated with the\r
+ returned <a href="#robo381">cl_list_iterator_t</a>.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> <a href="#robo15">List</a>, <a href="#robo391">cl_list_tail</a>, <a href="#robo382">cl_list_next</a>, <a href="#robo384">cl_list_prev</a>, <a href="#robo370">cl_list_end</a>,\r
+ <a href="#robo383">cl_list_obj</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo374">[Functions]<a name="Component20Library3a20List2fcl5flist5finit">\r
+Component Library: List/cl_list_init</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_list_init</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_list_init</strong> function initializes a list for use.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT <a href="./cl_types_h.html#robo304">cl_status_t</a> CL_API\r
+<strong>cl_list_init</strong>(\r
+ IN <a href="#robo390">cl_list_t</a>* const p_list,\r
+ IN const size_t min_items );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_list\r
+ [in] Pointer to <a href="#robo390">cl_list_t</a> structure to initialize.\r
+\r
+ min_items\r
+ [in] Minimum number of items that can be stored. All necessary\r
+ allocations to allow storing the minimum number of items is performed\r
+ at initialization time.\r
+\r
+ RETURN VALUES\r
+ CL_SUCCESS if the list was initialized successfully.\r
+\r
+ CL_INSUFFICIENT_MEMORY if there was not enough memory for initialization.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> The list will always be able to store at least as many items as specified\r
+ by the min_items parameter.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> <a href="#robo15">List</a>, <a href="#robo367">cl_list_construct</a>, <a href="#robo369">cl_list_destroy</a>, <a href="#robo377">cl_list_insert_head</a>,\r
+ <a href="#robo380">cl_list_insert_tail</a>, <a href="#robo386">cl_list_remove_head</a>, <a href="#robo389">cl_list_remove_tail</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo375">[Functions]<a name="Component20Library3a20List2fcl5flist5finsert5farray5fhead">\r
+Component Library: List/cl_list_insert_array_head</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_list_insert_array_head</strong>\r
+\r
+ DESCRIPTION:\r
+ The <strong>cl_list_insert_array_head</strong> function inserts an array of objects\r
+ at the head of a list.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT <a href="./cl_types_h.html#robo304">cl_status_t</a> CL_API\r
+<strong>cl_list_insert_array_head</strong>(\r
+ IN <a href="#robo390">cl_list_t</a>* const p_list,\r
+ IN const void* const p_array,\r
+ IN uint32_t item_count,\r
+ IN const uint32_t item_size );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_list\r
+ [in] Pointer to a <a href="#robo390">cl_list_t</a> structure into which to insert the objects.\r
+\r
+ p_array\r
+ [in] Pointer to the first object in an array.\r
+\r
+ item_count\r
+ [in] Number of objects in the array.\r
+\r
+ item_size\r
+ [in] Size of the objects added to the list. This is the stride in the\r
+ array from one object to the next.\r
+\r
+ RETURN VALUES\r
+ CL_SUCCESS if the insertion was successful.\r
+\r
+ CL_INSUFFICIENT_MEMORY if there was not enough memory for the insertion.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> Inserts all objects in the array to the head of the list, preserving the\r
+ ordering of the objects. If not successful, no items are added.\r
+ <a href="#robo15">List</a> insertion operations are guaranteed to work for the minimum number\r
+ of items as specified in <a href="#robo374">cl_list_init</a> by the min_items parameter.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> <a href="#robo15">List</a>, <a href="#robo376">cl_list_insert_array_tail</a>, <a href="#robo377">cl_list_insert_head</a>, <a href="#robo380">cl_list_insert_tail</a>,\r
+ <a href="#robo379">cl_list_insert_prev</a>, <a href="#robo378">cl_list_insert_next</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo376">[Functions]<a name="Component20Library3a20List2fcl5flist5finsert5farray5ftail">\r
+Component Library: List/cl_list_insert_array_tail</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_list_insert_array_tail</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_list_insert_array_tail</strong> function inserts an array of objects\r
+ at the tail of a list.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT <a href="./cl_types_h.html#robo304">cl_status_t</a> CL_API\r
+<strong>cl_list_insert_array_tail</strong>(\r
+ IN <a href="#robo390">cl_list_t</a>* const p_list,\r
+ IN const void* const p_array,\r
+ IN uint32_t item_count,\r
+ IN const uint32_t item_size);\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_list\r
+ [in] Pointer to a <a href="#robo390">cl_list_t</a> structure into which to insert the objects.\r
+\r
+ p_array\r
+ [in] Pointer to the first object in an array.\r
+\r
+ item_count\r
+ [in] Number of objects in the array.\r
+\r
+ item_size\r
+ [in] Size of the objects added to the list. This is the stride in the\r
+ array from one object to the next.\r
+\r
+ RETURN VALUES\r
+ CL_SUCCESS if the insertion was successful.\r
+\r
+ CL_INSUFFICIENT_MEMORY if there was not enough memory for the insertion.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> Inserts all objects in the array to the tail of the list, preserving the\r
+ ordering of the objects. If not successful, no items are added.\r
+ <a href="#robo15">List</a> insertion operations are guaranteed to work for the minimum number\r
+ of items as specified in <a href="#robo374">cl_list_init</a> by the min_items parameter.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> <a href="#robo15">List</a>, <a href="#robo375">cl_list_insert_array_head</a>, <a href="#robo377">cl_list_insert_head</a>, <a href="#robo380">cl_list_insert_tail</a>,\r
+ <a href="#robo379">cl_list_insert_prev</a>, <a href="#robo378">cl_list_insert_next</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo377">[Functions]<a name="Component20Library3a20List2fcl5flist5finsert5fhead">\r
+Component Library: List/cl_list_insert_head</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_list_insert_head</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_list_insert_head</strong> function inserts an object at the head of a list.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_INLINE <a href="./cl_types_h.html#robo304">cl_status_t</a> CL_API\r
+<strong>cl_list_insert_head</strong>(\r
+ IN <a href="#robo390">cl_list_t</a>* const p_list,\r
+ IN const void* const p_object )\r
+{\r
+ cl_pool_obj_t *p_pool_obj;\r
+\r
+ CL_ASSERT( p_list );\r
+ CL_ASSERT( <a href="./cl_qpool_h.html#robo615">cl_is_qpool_inited</a>( &p_list->list_item_pool ) );\r
+\r
+ /* Get a list item to add to the list. */\r
+ p_pool_obj = (cl_pool_obj_t*)<a href="./cl_qpool_h.html#robo621">cl_qpool_get</a>( &p_list->list_item_pool );\r
+ if( !p_pool_obj )\r
+ return( CL_INSUFFICIENT_MEMORY );\r
+\r
+ p_pool_obj->list_obj.p_object = p_object;\r
+ <a href="./cl_qlist_h.html#robo569">cl_qlist_insert_head</a>( &p_list->list, &p_pool_obj->list_obj.list_item );\r
+ return( CL_SUCCESS );\r
+}\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_list\r
+ [in] Pointer to a <a href="#robo390">cl_list_t</a> structure into which to insert the object.\r
+\r
+ p_object\r
+ [in] Pointer to an object to insert into the list.\r
+\r
+ RETURN VALUES\r
+ CL_SUCCESS if the insertion was successful.\r
+\r
+ CL_INSUFFICIENT_MEMORY if there was not enough memory for the insertion.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> Inserts the specified object at the head of the list. <a href="#robo15">List</a> insertion\r
+ operations are guaranteed to work for the minimum number of items as\r
+ specified in <a href="#robo374">cl_list_init</a> by the min_items parameter.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> <a href="#robo15">List</a>, <a href="#robo380">cl_list_insert_tail</a>, <a href="#robo375">cl_list_insert_array_head</a>,\r
+ <a href="#robo376">cl_list_insert_array_tail</a>, <a href="#robo379">cl_list_insert_prev</a>, <a href="#robo378">cl_list_insert_next</a>,\r
+ <a href="#robo386">cl_list_remove_head</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo378">[Functions]<a name="Component20Library3a20List2fcl5flist5finsert5fnext">\r
+Component Library: List/cl_list_insert_next</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_list_insert_next</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_list_insert_next</strong> function inserts an object in a list after\r
+ the object associated with a given iterator.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_INLINE <a href="./cl_types_h.html#robo304">cl_status_t</a> CL_API\r
+<strong>cl_list_insert_next</strong>(\r
+ IN <a href="#robo390">cl_list_t</a>* const p_list,\r
+ IN const <a href="#robo381">cl_list_iterator_t</a> iterator,\r
+ IN const void* const p_object )\r
+{\r
+ cl_pool_obj_t *p_pool_obj;\r
+\r
+ CL_ASSERT( p_list );\r
+ CL_ASSERT( <a href="./cl_qpool_h.html#robo615">cl_is_qpool_inited</a>( &p_list->list_item_pool ) );\r
+\r
+ /* Get a list item to add to the list. */\r
+ p_pool_obj = (cl_pool_obj_t*)<a href="./cl_qpool_h.html#robo621">cl_qpool_get</a>( &p_list->list_item_pool );\r
+ if( !p_pool_obj )\r
+ return( CL_INSUFFICIENT_MEMORY );\r
+\r
+ p_pool_obj->list_obj.p_object = p_object;\r
+ <a href="./cl_qlist_h.html#robo572">cl_qlist_insert_next</a>( &p_list->list, (<a href="./cl_qlist_h.html#robo554">cl_list_item_t</a>*)iterator,\r
+ &p_pool_obj->list_obj.list_item );\r
+ return( CL_SUCCESS );\r
+}\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_list\r
+ [in] Pointer to a <a href="#robo390">cl_list_t</a> structure into which to insert the object.\r
+\r
+ iterator\r
+ [in] <a href="#robo381">cl_list_iterator_t</a> returned by a previous call to <a href="#robo373">cl_list_head</a>,\r
+ <a href="#robo391">cl_list_tail</a>, <a href="#robo382">cl_list_next</a>, or <a href="#robo384">cl_list_prev</a>.\r
+\r
+ p_object\r
+ [in] Pointer to an object to insert into the list.\r
+\r
+ RETURN VALUES\r
+ CL_SUCCESS if the insertion was successful.\r
+\r
+ CL_INSUFFICIENT_MEMORY if there was not enough memory for the insertion.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> <a href="#robo15">List</a>, <a href="#robo379">cl_list_insert_prev</a>, <a href="#robo377">cl_list_insert_head</a>, <a href="#robo380">cl_list_insert_tail</a>,\r
+ <a href="#robo375">cl_list_insert_array_head</a>, <a href="#robo376">cl_list_insert_array_tail</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo379">[Functions]<a name="Component20Library3a20List2fcl5flist5finsert5fprev">\r
+Component Library: List/cl_list_insert_prev</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_list_insert_prev</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_list_insert_prev</strong> function inserts an object in a list before\r
+ the object associated with a given iterator.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_INLINE <a href="./cl_types_h.html#robo304">cl_status_t</a> CL_API\r
+<strong>cl_list_insert_prev</strong>(\r
+ IN <a href="#robo390">cl_list_t</a>* const p_list,\r
+ IN const <a href="#robo381">cl_list_iterator_t</a> iterator,\r
+ IN const void* const p_object )\r
+{\r
+ cl_pool_obj_t *p_pool_obj;\r
+\r
+ CL_ASSERT( p_list );\r
+ CL_ASSERT( <a href="./cl_qpool_h.html#robo615">cl_is_qpool_inited</a>( &p_list->list_item_pool ) );\r
+\r
+ /* Get a list item to add to the list. */\r
+ p_pool_obj = (cl_pool_obj_t*)<a href="./cl_qpool_h.html#robo621">cl_qpool_get</a>( &p_list->list_item_pool );\r
+ if( !p_pool_obj )\r
+ return( CL_INSUFFICIENT_MEMORY );\r
+\r
+ p_pool_obj->list_obj.p_object = p_object;\r
+ <a href="./cl_qlist_h.html#robo573">cl_qlist_insert_prev</a>( &p_list->list, (<a href="./cl_qlist_h.html#robo554">cl_list_item_t</a>*)iterator,\r
+ &p_pool_obj->list_obj.list_item );\r
+ return( CL_SUCCESS );\r
+}\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_list\r
+ [in] Pointer to a <a href="#robo390">cl_list_t</a> structure into which to insert the object.\r
+\r
+ iterator\r
+ [in] <a href="#robo381">cl_list_iterator_t</a> returned by a previous call to <a href="#robo373">cl_list_head</a>,\r
+ <a href="#robo391">cl_list_tail</a>, <a href="#robo382">cl_list_next</a>, or <a href="#robo384">cl_list_prev</a>.\r
+\r
+ p_object\r
+ [in] Pointer to an object to insert into the list.\r
+\r
+ RETURN VALUES\r
+ CL_SUCCESS if the insertion was successful.\r
+\r
+ CL_INSUFFICIENT_MEMORY if there was not enough memory for the insertion.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> <a href="#robo15">List</a>, <a href="#robo378">cl_list_insert_next</a>, <a href="#robo377">cl_list_insert_head</a>, <a href="#robo380">cl_list_insert_tail</a>,\r
+ <a href="#robo375">cl_list_insert_array_head</a>, <a href="#robo376">cl_list_insert_array_tail</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo380">[Functions]<a name="Component20Library3a20List2fcl5flist5finsert5ftail">\r
+Component Library: List/cl_list_insert_tail</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_list_insert_tail</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_list_insert_tail</strong> function inserts an object at the head of a list.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_INLINE <a href="./cl_types_h.html#robo304">cl_status_t</a> CL_API\r
+<strong>cl_list_insert_tail</strong>(\r
+ IN <a href="#robo390">cl_list_t</a>* const p_list,\r
+ IN const void* const p_object )\r
+{\r
+ cl_pool_obj_t *p_pool_obj;\r
+\r
+ CL_ASSERT( p_list );\r
+ CL_ASSERT( <a href="./cl_qpool_h.html#robo615">cl_is_qpool_inited</a>( &p_list->list_item_pool ) );\r
+\r
+ /* Get a list item to add to the list. */\r
+ p_pool_obj = (cl_pool_obj_t*)<a href="./cl_qpool_h.html#robo621">cl_qpool_get</a>( &p_list->list_item_pool );\r
+ if( !p_pool_obj )\r
+ return( CL_INSUFFICIENT_MEMORY );\r
+\r
+ p_pool_obj->list_obj.p_object = p_object;\r
+ <a href="./cl_qlist_h.html#robo574">cl_qlist_insert_tail</a>( &p_list->list, &p_pool_obj->list_obj.list_item );\r
+ return( CL_SUCCESS );\r
+}\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_list\r
+ [in] Pointer to a <a href="#robo390">cl_list_t</a> structure into which to insert the object.\r
+\r
+ p_object\r
+ [in] Pointer to an object to insert into the list.\r
+\r
+ RETURN VALUES\r
+ CL_SUCCESS if the insertion was successful.\r
+\r
+ CL_INSUFFICIENT_MEMORY if there was not enough memory for the insertion.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> Inserts the specified object at the tail of the list. <a href="#robo15">List</a> insertion\r
+ operations are guaranteed to work for the minimum number of items as\r
+ specified in <a href="#robo374">cl_list_init</a> by the min_items parameter.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> <a href="#robo15">List</a>, <a href="#robo377">cl_list_insert_head</a>, <a href="#robo375">cl_list_insert_array_head</a>,\r
+ <a href="#robo376">cl_list_insert_array_tail</a>, <a href="#robo379">cl_list_insert_prev</a>, <a href="#robo378">cl_list_insert_next</a>,\r
+ <a href="#robo389">cl_list_remove_tail</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo381">[Definitions]<a name="Component20Library3a20List2fcl5flist5fiterator5ft">\r
+Component Library: List/cl_list_iterator_t</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_definitions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_list_iterator_t</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> Iterator type used to walk a list.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>typedef const <a href="./cl_qlist_h.html#robo554">cl_list_item_t</a> *<strong>cl_list_iterator_t</strong>;\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> The iterator should be treated as opaque to prevent corrupting the list.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> <a href="#robo15">List</a>, <a href="#robo373">cl_list_head</a>, <a href="#robo391">cl_list_tail</a>, <a href="#robo382">cl_list_next</a>, <a href="#robo384">cl_list_prev</a>,\r
+ <a href="#robo383">cl_list_obj</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo382">[Functions]<a name="Component20Library3a20List2fcl5flist5fnext">\r
+Component Library: List/cl_list_next</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_list_next</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_list_next</strong> function returns a list iterator for the object stored\r
+ in a list after the object associated with a given list iterator.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_INLINE const <a href="#robo381">cl_list_iterator_t</a> CL_API\r
+<strong>cl_list_next</strong>(\r
+ IN const <a href="#robo381">cl_list_iterator_t</a> iterator )\r
+{\r
+ CL_ASSERT( iterator );\r
+\r
+ return( <a href="./cl_qlist_h.html#robo576">cl_qlist_next</a>( iterator ) );\r
+}\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_list\r
+ [in] Pointer to a <a href="#robo390">cl_list_t</a> structure for which the iterator for the\r
+ next object is to be returned.\r
+\r
+ iterator\r
+ [in] <a href="#robo381">cl_list_iterator_t</a> returned by a previous call to <a href="#robo373">cl_list_head</a>,\r
+ <a href="#robo391">cl_list_tail</a>, <strong>cl_list_next</strong>, or <a href="#robo384">cl_list_prev</a>.\r
+\r
+ RETURN VALUES\r
+ <a href="#robo381">cl_list_iterator_t</a> for the object following the object associated with\r
+ the list iterator specified by the iterator parameter.\r
+\r
+ <a href="#robo381">cl_list_iterator_t</a> for the end of the list if the list is empty.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> Use <a href="#robo383">cl_list_obj</a> to retrieve the object associated with the\r
+ returned <a href="#robo381">cl_list_iterator_t</a>.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> <a href="#robo15">List</a>, <a href="#robo384">cl_list_prev</a>, <a href="#robo373">cl_list_head</a>, <a href="#robo391">cl_list_tail</a>, <a href="#robo370">cl_list_end</a>,\r
+ <a href="#robo383">cl_list_obj</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo383">[Functions]<a name="Component20Library3a20List2fcl5flist5fobj">\r
+Component Library: List/cl_list_obj</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_list_obj</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_list_obj</strong> function returns the object associated\r
+ with a list iterator.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_INLINE void* CL_API\r
+<strong>cl_list_obj</strong>(\r
+ IN const <a href="#robo381">cl_list_iterator_t</a> iterator )\r
+{\r
+ CL_ASSERT( iterator );\r
+\r
+ return( (void*)((cl_pool_obj_t*)iterator)->list_obj.p_object );\r
+}\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> iterator\r
+ [in] <a href="#robo381">cl_list_iterator_t</a> returned by a previous call to <a href="#robo373">cl_list_head</a>,\r
+ <a href="#robo391">cl_list_tail</a>, <a href="#robo382">cl_list_next</a>, or <a href="#robo384">cl_list_prev</a> whose object is requested.\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> Pointer to the object associated with the list iterator specified\r
+ by the iterator parameter.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> <a href="#robo15">List</a>, <a href="#robo373">cl_list_head</a>, <a href="#robo391">cl_list_tail</a>, <a href="#robo382">cl_list_next</a>, <a href="#robo384">cl_list_prev</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo384">[Functions]<a name="Component20Library3a20List2fcl5flist5fprev">\r
+Component Library: List/cl_list_prev</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_list_prev</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_list_prev</strong> function returns a list iterator for the object stored\r
+ in a list before the object associated with a given list iterator.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_INLINE const <a href="#robo381">cl_list_iterator_t</a> CL_API\r
+<strong>cl_list_prev</strong>(\r
+ IN const <a href="#robo381">cl_list_iterator_t</a> iterator )\r
+{\r
+ CL_ASSERT( iterator );\r
+\r
+ return( <a href="./cl_qlist_h.html#robo578">cl_qlist_prev</a>( iterator ) );\r
+}\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_list\r
+ [in] Pointer to a <a href="#robo390">cl_list_t</a> structure for which the iterator for the\r
+ next object is to be returned.\r
+\r
+ iterator\r
+ [in] <a href="#robo381">cl_list_iterator_t</a> returned by a previous call to <a href="#robo373">cl_list_head</a>,\r
+ <a href="#robo391">cl_list_tail</a>, <a href="#robo382">cl_list_next</a>, or <strong>cl_list_prev</strong>.\r
+\r
+ RETURN VALUES\r
+ <a href="#robo381">cl_list_iterator_t</a> for the object preceding the object associated with\r
+ the list iterator specified by the iterator parameter.\r
+\r
+ <a href="#robo381">cl_list_iterator_t</a> for the end of the list if the list is empty.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> Use <a href="#robo383">cl_list_obj</a> to retrieve the object associated with the\r
+ returned <a href="#robo381">cl_list_iterator_t</a>.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> <a href="#robo15">List</a>, <a href="#robo382">cl_list_next</a>, <a href="#robo373">cl_list_head</a>, <a href="#robo391">cl_list_tail</a>, <a href="#robo370">cl_list_end</a>,\r
+ <a href="#robo383">cl_list_obj</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo385">[Functions]<a name="Component20Library3a20List2fcl5flist5fremove5fall">\r
+Component Library: List/cl_list_remove_all</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_list_remove_all</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_list_remove_all</strong> function removes all objects from a list,\r
+ leaving it empty.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_INLINE void CL_API\r
+<strong>cl_list_remove_all</strong>(\r
+ IN <a href="#robo390">cl_list_t</a>* const p_list )\r
+{\r
+ CL_ASSERT( p_list );\r
+ CL_ASSERT( <a href="./cl_qpool_h.html#robo615">cl_is_qpool_inited</a>( &p_list->list_item_pool ) );\r
+\r
+ /* Return all the list items to the pool. */\r
+ <a href="./cl_qpool_h.html#robo625">cl_qpool_put_list</a>( &p_list->list_item_pool, &p_list->list );\r
+}\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_list\r
+ [in] Pointer to a <a href="#robo390">cl_list_t</a> structure from which to remove all objects.\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> This function does not return a value.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> <a href="#robo15">List</a>, <a href="#robo386">cl_list_remove_head</a>, <a href="#robo389">cl_list_remove_tail</a>, <a href="#robo388">cl_list_remove_object</a>,\r
+ <a href="#robo387">cl_list_remove_item</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo386">[Functions]<a name="Component20Library3a20List2fcl5flist5fremove5fhead">\r
+Component Library: List/cl_list_remove_head</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_list_remove_head</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_list_remove_head</strong> function removes an object from the head of a list.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_INLINE void* CL_API\r
+<strong>cl_list_remove_head</strong>(\r
+ IN <a href="#robo390">cl_list_t</a>* const p_list )\r
+{\r
+ cl_pool_obj_t *p_pool_obj;\r
+\r
+ CL_ASSERT( p_list );\r
+ CL_ASSERT( <a href="./cl_qpool_h.html#robo615">cl_is_qpool_inited</a>( &p_list->list_item_pool ) );\r
+\r
+ /* See if the list is empty. */\r
+ if( <a href="./cl_qlist_h.html#robo553">cl_is_qlist_empty</a>( &p_list->list ) )\r
+ return( NULL );\r
+\r
+ /* Get the item at the head of the list. */\r
+ p_pool_obj = (cl_pool_obj_t*)<a href="./cl_qlist_h.html#robo580">cl_qlist_remove_head</a>( &p_list->list );\r
+\r
+ /* Place the pool item back into the pool. */\r
+ <a href="./cl_qpool_h.html#robo624">cl_qpool_put</a>( &p_list->list_item_pool, (<a href="./cl_qcomppool_h.html#robo542">cl_pool_item_t</a>*)p_pool_obj );\r
+\r
+ return( (void*)p_pool_obj->list_obj.p_object );\r
+}\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_list\r
+ [in] Pointer to a <a href="#robo390">cl_list_t</a> structure from which to remove an object.\r
+\r
+ RETURN VALUES\r
+ Returns the pointer to the object formerly at the head of the list.\r
+\r
+ NULL if the list was empty.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> <a href="#robo15">List</a>, <a href="#robo389">cl_list_remove_tail</a>, <a href="#robo385">cl_list_remove_all</a>, <a href="#robo388">cl_list_remove_object</a>,\r
+ <a href="#robo387">cl_list_remove_item</a>, <a href="#robo377">cl_list_insert_head</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo387">[Functions]<a name="Component20Library3a20List2fcl5flist5fremove5fitem">\r
+Component Library: List/cl_list_remove_item</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_list_remove_item</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_list_remove_item</strong> function removes an object from the head of a list.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_INLINE void CL_API\r
+<strong>cl_list_remove_item</strong>(\r
+ IN <a href="#robo390">cl_list_t</a>* const p_list,\r
+ IN const <a href="#robo381">cl_list_iterator_t</a> iterator )\r
+{\r
+ CL_ASSERT( p_list );\r
+ CL_ASSERT( <a href="./cl_qpool_h.html#robo615">cl_is_qpool_inited</a>( &p_list->list_item_pool ) );\r
+\r
+ <a href="./cl_qlist_h.html#robo581">cl_qlist_remove_item</a>( &p_list->list, (<a href="./cl_qlist_h.html#robo554">cl_list_item_t</a>*)iterator );\r
+\r
+ /* Place the list item back into the pool. */\r
+ <a href="./cl_qpool_h.html#robo624">cl_qpool_put</a>( &p_list->list_item_pool, (<a href="./cl_qcomppool_h.html#robo542">cl_pool_item_t</a>*)iterator );\r
+}\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_list\r
+ [in] Pointer to a <a href="#robo390">cl_list_t</a> structure from which to remove the item.\r
+\r
+ iterator\r
+ [in] <a href="#robo381">cl_list_iterator_t</a> returned by a previous call to <a href="#robo373">cl_list_head</a>,\r
+ <a href="#robo391">cl_list_tail</a>, <a href="#robo382">cl_list_next</a>, or <a href="#robo384">cl_list_prev</a>.\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> This function does not return a value.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> <a href="#robo15">List</a>, <a href="#robo388">cl_list_remove_object</a>, <a href="#robo386">cl_list_remove_head</a>, <a href="#robo389">cl_list_remove_tail</a>,\r
+ <a href="#robo385">cl_list_remove_all</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo388">[Functions]<a name="Component20Library3a20List2fcl5flist5fremove5fobject">\r
+Component Library: List/cl_list_remove_object</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_list_remove_object</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_list_remove_object</strong> function removes a specific object from a list.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT <a href="./cl_types_h.html#robo304">cl_status_t</a> CL_API\r
+<strong>cl_list_remove_object</strong>(\r
+ IN <a href="#robo390">cl_list_t</a>* const p_list,\r
+ IN const void* const p_object );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_list\r
+ [in] Pointer to a <a href="#robo390">cl_list_t</a> structure from which to remove the object.\r
+\r
+ p_object\r
+ [in] Pointer to an object to remove from the list.\r
+\r
+ RETURN VALUES\r
+ CL_SUCCESS if the object was removed.\r
+\r
+ CL_NOT_FOUND if the object was not found in the list.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> Removes the first occurrence of an object from a list.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> <a href="#robo15">List</a>, <a href="#robo387">cl_list_remove_item</a>, <a href="#robo386">cl_list_remove_head</a>, <a href="#robo389">cl_list_remove_tail</a>,\r
+ <a href="#robo385">cl_list_remove_all</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo389">[Functions]<a name="Component20Library3a20List2fcl5flist5fremove5ftail">\r
+Component Library: List/cl_list_remove_tail</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_list_remove_tail</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_list_remove_tail</strong> function removes an object from the tail of a list.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_INLINE void* CL_API\r
+<strong>cl_list_remove_tail</strong>(\r
+ IN <a href="#robo390">cl_list_t</a>* const p_list )\r
+{\r
+ cl_pool_obj_t *p_pool_obj;\r
+\r
+ CL_ASSERT( p_list );\r
+ CL_ASSERT( <a href="./cl_qpool_h.html#robo615">cl_is_qpool_inited</a>( &p_list->list_item_pool ) );\r
+\r
+ /* See if the list is empty. */\r
+ if( <a href="./cl_qlist_h.html#robo553">cl_is_qlist_empty</a>( &p_list->list ) )\r
+ return( NULL );\r
+\r
+ /* Get the item at the head of the list. */\r
+ p_pool_obj = (cl_pool_obj_t*)<a href="./cl_qlist_h.html#robo582">cl_qlist_remove_tail</a>( &p_list->list );\r
+\r
+ /* Place the list item back into the pool. */\r
+ <a href="./cl_qpool_h.html#robo624">cl_qpool_put</a>( &p_list->list_item_pool, (<a href="./cl_qcomppool_h.html#robo542">cl_pool_item_t</a>*)p_pool_obj );\r
+\r
+ return( (void*)p_pool_obj->list_obj.p_object );\r
+}\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_list\r
+ [in] Pointer to a <a href="#robo390">cl_list_t</a> structure from which to remove an object.\r
+\r
+ RETURN VALUES\r
+ Returns the pointer to the object formerly at the tail of the list.\r
+\r
+ NULL if the list was empty.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> <a href="#robo15">List</a>, <a href="#robo386">cl_list_remove_head</a>, <a href="#robo385">cl_list_remove_all</a>, <a href="#robo388">cl_list_remove_object</a>,\r
+ <a href="#robo387">cl_list_remove_item</a>, <a href="#robo377">cl_list_insert_head</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo390">[Structures]<a name="Component20Library3a20List2fcl5flist5ft">\r
+Component Library: List/cl_list_t</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_strutures.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_list_t</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> <a href="#robo15">List</a> structure.\r
+\r
+ The <strong>cl_list_t</strong> structure should be treated as opaque and should be\r
+ manipulated only through the provided functions.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>typedef struct _cl_list\r
+{\r
+ <a href="./cl_qlist_h.html#robo584">cl_qlist_t</a> list;\r
+ <a href="./cl_qpool_h.html#robo626">cl_qpool_t</a> list_item_pool;\r
+\r
+} <strong>cl_list_t</strong>;\r
+</pre>\r
+</span><p><strong>FIELDS</strong></p>\r
+<span class="FIELDS"><pre> list\r
+ Quick list of items stored in the list.\r
+\r
+ list_item_pool\r
+ Quick pool of list objects for storing objects in the quick list.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> <a href="#robo15">List</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo391">[Functions]<a name="Component20Library3a20List2fcl5flist5ftail">\r
+Component Library: List/cl_list_tail</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_list_tail</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_list_tail</strong> function returns returns a list iterator for\r
+ the tail of a list.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_INLINE const <a href="#robo381">cl_list_iterator_t</a> CL_API\r
+<strong>cl_list_tail</strong>(\r
+ IN const <a href="#robo390">cl_list_t</a>* const p_list )\r
+{\r
+ CL_ASSERT( p_list );\r
+ CL_ASSERT( <a href="./cl_qpool_h.html#robo615">cl_is_qpool_inited</a>( &p_list->list_item_pool ) );\r
+\r
+ return( <a href="./cl_qlist_h.html#robo585">cl_qlist_tail</a>( &p_list->list ) );\r
+}\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_list\r
+ [in] Pointer to a <a href="#robo390">cl_list_t</a> structure for which the iterator for the\r
+ object at the tail is to be returned.\r
+\r
+ RETURN VALUES\r
+ <a href="#robo381">cl_list_iterator_t</a> for the tail of the list.\r
+\r
+ <a href="#robo381">cl_list_iterator_t</a> for the end of the list if the list is empty.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> Use <a href="#robo383">cl_list_obj</a> to retrieve the object associated with the\r
+\r
+ returned <a href="#robo381">cl_list_iterator_t</a>.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> <a href="#robo15">List</a>, <a href="#robo373">cl_list_head</a>, <a href="#robo382">cl_list_next</a>, <a href="#robo384">cl_list_prev</a>, <a href="#robo370">cl_list_end</a>,\r
+ <a href="#robo383">cl_list_obj</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo392">[Definitions]<a name="Component20Library3a20List2fcl5fpfn5flist5fapply5ft">\r
+Component Library: List/cl_pfn_list_apply_t</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_definitions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_pfn_list_apply_t</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_pfn_list_apply_t</strong> function type defines the prototype for functions\r
+ used to iterate objects in a list.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>typedef void\r
+(CL_API *<strong>cl_pfn_list_apply_t</strong>)(\r
+ IN void* const p_object,\r
+ IN void* context );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_object\r
+ [in] Pointer to an object stored in a list.\r
+\r
+ context\r
+ [in] Context provided in a call to <a href="#robo366">cl_list_apply_func</a>.\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> This function does not return a value.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> This function type is provided as function prototype reference for the\r
+ function provided by users as a parameter to the <a href="#robo366">cl_list_apply_func</a>\r
+ function.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> <a href="#robo15">List</a>, <a href="#robo366">cl_list_apply_func</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo393">[Definitions]<a name="Component20Library3a20List2fcl5fpfn5flist5ffind5ft">\r
+Component Library: List/cl_pfn_list_find_t</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_definitions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_pfn_list_find_t</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_pfn_list_find_t</strong> function type defines the prototype for functions\r
+ used to find objects in a list.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>typedef <a href="./cl_types_h.html#robo304">cl_status_t</a>\r
+(CL_API *<strong>cl_pfn_list_find_t</strong>)(\r
+ IN const void* const p_object,\r
+ IN void* context );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_object\r
+ [in] Pointer to an object stored in a list.\r
+\r
+ context\r
+ [in] Context provided in a call to ListFindFromHead or ListFindFromTail.\r
+\r
+ RETURN VALUES\r
+ Return CL_SUCCESS if the desired item was found. This stops list iteration.\r
+\r
+ Return CL_NOT_FOUND to continue the list iteration.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> This function type is provided as function prototype reference for the\r
+ function provided by users as a parameter to the <a href="#robo371">cl_list_find_from_head</a>\r
+ and <a href="#robo372">cl_list_find_from_tail</a> functions.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> <a href="#robo15">List</a>, <a href="#robo371">cl_list_find_from_head</a>, <a href="#robo372">cl_list_find_from_tail</a>\r
+</pre>\r
+</span>\r
+</body>\r
+</html>\r
--- /dev/null
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">\r
+<html>\r
+<head>\r
+<link rel="stylesheet" href="../robodoc.css" type="text/css">\r
+<title>./inc_doc/complib/cl_log_h.html</title>\r
+<!-- Source: ./inc/complib/cl_log.h -->\r
+<!-- Generated with ROBODoc Version 4.99.22 (Mar 6 2006) -->\r
+</head>\r
+<body bgcolor="#FFFFFF">\r
+<a name="robo_top_of_doc">Generated from ./inc/complib/cl_log.h</a> with <a href="http://sourceforge.net/projects/robodoc/">ROBODoc</a> v4.99.22 on Sun Apr 16 2006 17:39:25\r
+<br />\r
+<hr />\r
+\r
+<h2><a name="robo16">[Modules]<a name="Component20Library2fLog20Provider">\r
+Component Library/Log Provider</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_modules.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> Log Provider\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The log provider allows users to log information in a system log instead of\r
+ the console or debugger target.\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo394">[Functions]<a name="Component20Library3a20Log20Provider2fcl5flog5fevent">\r
+Component Library: Log Provider/cl_log_event</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_log_event</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_log_event</strong> function adds a new entry to the system log.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT void CL_API\r
+<strong>cl_log_event</strong>(\r
+ IN const char* const name,\r
+ IN const <a href="#robo395">cl_log_type_t</a> type,\r
+ IN const char* const message,\r
+ IN const void* const p_data OPTIONAL,\r
+ IN const uint32_t data_len );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> name\r
+ [in] Pointer to an ANSI string containing the name of the source for\r
+ the log entry.\r
+\r
+ type\r
+ [in] Defines the type of log entry to add to the system log.\r
+ See the definition of <a href="#robo395">cl_log_type_t</a> for acceptable values.\r
+\r
+ message\r
+ [in] Pointer to an ANSI string containing the text for the log entry.\r
+ The message should not be terminated with a new line, as the log\r
+ provider appends a new line to all log entries.\r
+\r
+ p_data\r
+ [in] Optional pointer to data providing context for the log entry.\r
+ At most 256 bytes of data can be successfully logged.\r
+\r
+ data_len\r
+ [in] Length of the buffer pointed to by the p_data parameter. Ignored\r
+ if p_data is NULL.\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> This function does not return a value.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> If the data length exceeds the maximum supported, the event is logged\r
+ without its accompanying data.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Log Provider, <a href="#robo395">cl_log_type_t</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo395">[Definitions]<a name="Component20Library3a20Log20Provider2fcl5flog5ftype5ft">\r
+Component Library: Log Provider/cl_log_type_t</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_definitions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_log_type_t</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_log_type_t</strong> enumerated type is used to differentiate between\r
+ different types of log entries.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>typedef enum _cl_log_type\r
+{\r
+ CL_LOG_INFO,\r
+ CL_LOG_WARN,\r
+ CL_LOG_ERROR\r
+\r
+} <strong>cl_log_type_t</strong>;\r
+</pre>\r
+</span><p><strong>VALUES</strong></p>\r
+<span class="VALUES"><pre> CL_LOG_INFO\r
+ Indicates a log entry is purely informational.\r
+\r
+ CL_LOG_WARN\r
+ Indicates a log entry is a warning but non-fatal.\r
+\r
+ CL_LOG_ERROR\r
+ Indicates a log entry is a fatal error.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Log Provider, <a href="#robo394">cl_log_event</a>\r
+</pre>\r
+</span>\r
+</body>\r
+</html>\r
--- /dev/null
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">\r
+<html>\r
+<head>\r
+<link rel="stylesheet" href="../robodoc.css" type="text/css">\r
+<title>./inc_doc/complib/cl_map_h.html</title>\r
+<!-- Source: ./inc/complib/cl_map.h -->\r
+<!-- Generated with ROBODoc Version 4.99.22 (Mar 6 2006) -->\r
+</head>\r
+<body bgcolor="#FFFFFF">\r
+<a name="robo_top_of_doc">Generated from ./inc/complib/cl_map.h</a> with <a href="http://sourceforge.net/projects/robodoc/">ROBODoc</a> v4.99.22 on Sun Apr 16 2006 17:39:25\r
+<br />\r
+<hr />\r
+\r
+<h2><a name="robo17">[Modules]<a name="Component20Library2fMap">\r
+Component Library/Map</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_modules.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>Map</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> <strong>Map</strong> implements a binary tree that stores user objects. Each item stored\r
+ in a map has a unique 64-bit key (duplicates are not allowed). <strong>Map</strong>\r
+ provides the ability to efficiently search for an item given a key.\r
+\r
+ <strong>Map</strong> may allocate memory when inserting objects, and can therefore fail\r
+ operations due to insufficient memory. Use quick map in situations where\r
+ such insertion failures cannot be tolerated.\r
+\r
+ <strong>Map</strong> is not thread safe, and users must provide serialization when adding\r
+ and removing items from the map.\r
+\r
+ The map functions operates on a <a href="#robo415">cl_map_t</a> structure which should be treated\r
+ as opaque and should be manipulated only through the provided functions.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> Types:\r
+ <a href="#robo406">cl_map_iterator_t</a>\r
+\r
+ Structures:\r
+ <a href="#robo415">cl_map_t</a>, <a href="./cl_qmap_h.html#robo593">cl_map_item_t</a>, <a href="./cl_qmap_h.html#robo594">cl_map_obj_t</a>\r
+\r
+ Item Manipulation:\r
+ <a href="#robo410">cl_map_obj</a>, <a href="#robo407">cl_map_key</a>\r
+\r
+ Initialization:\r
+ <a href="#robo397">cl_map_construct</a>, <a href="#robo404">cl_map_init</a>, <a href="#robo400">cl_map_destroy</a>\r
+\r
+ Iteration:\r
+ <a href="#robo401">cl_map_end</a>, <a href="#robo403">cl_map_head</a>, <a href="#robo416">cl_map_tail</a>, <a href="#robo409">cl_map_next</a>, <a href="#robo411">cl_map_prev</a>\r
+\r
+ Manipulation\r
+ <a href="#robo405">cl_map_insert</a>, <a href="#robo402">cl_map_get</a>, <a href="#robo414">cl_map_remove_item</a>, <a href="#robo412">cl_map_remove</a>,\r
+ <a href="#robo413">cl_map_remove_all</a>, <a href="#robo408">cl_map_merge</a>, <a href="#robo399">cl_map_delta</a>\r
+\r
+ Attributes:\r
+ <a href="#robo398">cl_map_count</a>, <a href="#robo396">cl_is_map_empty</a>, <a href="#robo322">cl_is_map_inited</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo322">[Functions]<a name="Component20Library3a20Event2fcl5fis5fmap5finited">\r
+Component Library: Event/cl_is_map_inited</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_is_map_inited</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_is_map_inited</strong> function returns whether a map was\r
+ successfully initialized.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_INLINE boolean_t CL_API\r
+<strong>cl_is_map_inited</strong>(\r
+ IN const <a href="#robo415">cl_map_t</a>* const p_map )\r
+{\r
+ /*\r
+ * The map's pool of map items is the last thing initialized.\r
+ * We can therefore use it to test for initialization.\r
+ */\r
+ return( <a href="./cl_qpool_h.html#robo615">cl_is_qpool_inited</a>( &p_map->pool ) );\r
+}\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_map\r
+ [in] Pointer to a <a href="#robo415">cl_map_t</a> structure whose initialization state\r
+ to check.\r
+\r
+ RETURN VALUES\r
+ TRUE if the map was initialized successfully.\r
+\r
+ FALSE otherwise.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> Allows checking the state of a map to determine if invoking\r
+ member functions is appropriate.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> <a href="#robo17">Map</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo396">[Functions]<a name="Component20Library3a20Map2fcl5fis5fmap5fempty">\r
+Component Library: Map/cl_is_map_empty</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_is_map_empty</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_is_map_empty</strong> function returns whether a map is empty.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_INLINE boolean_t CL_API\r
+<strong>cl_is_map_empty</strong>(\r
+ IN const <a href="#robo415">cl_map_t</a>* const p_map )\r
+{\r
+ CL_ASSERT( p_map );\r
+ return( <a href="./cl_qmap_h.html#robo592">cl_is_qmap_empty</a>( &p_map->qmap ) );\r
+}\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_map\r
+ [in] Pointer to a map to test for emptiness.\r
+\r
+ RETURN VALUES\r
+ TRUE if the map is empty.\r
+\r
+ FALSE otherwise.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> <a href="#robo17">Map</a>, <a href="#robo398">cl_map_count</a>, <a href="#robo413">cl_map_remove_all</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo397">[Functions]<a name="Component20Library3a20Map2fcl5fmap5fconstruct">\r
+Component Library: Map/cl_map_construct</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_map_construct</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_map_construct</strong> function constructs a map.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT void CL_API\r
+<strong>cl_map_construct</strong>(\r
+ IN <a href="#robo415">cl_map_t</a>* const p_map );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_map\r
+ [in] Pointer to a <a href="#robo415">cl_map_t</a> structure to construct.\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> This function does not return a value.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> Allows calling <a href="#robo404">cl_map_init</a>, <a href="#robo400">cl_map_destroy</a>, and <a href="#robo322">cl_is_map_inited</a>.\r
+\r
+ Calling <strong>cl_map_construct</strong> is a prerequisite to calling any other\r
+ map function except <a href="#robo404">cl_map_init</a>.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> <a href="#robo17">Map</a>, <a href="#robo404">cl_map_init</a>, <a href="#robo400">cl_map_destroy</a>, <a href="#robo322">cl_is_map_inited</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo398">[Functions]<a name="Component20Library3a20Map2fcl5fmap5fcount">\r
+Component Library: Map/cl_map_count</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_map_count</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_map_count</strong> function returns the number of items stored\r
+ in a map.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_INLINE size_t CL_API\r
+<strong>cl_map_count</strong>(\r
+ IN const <a href="#robo415">cl_map_t</a>* const p_map )\r
+{\r
+ CL_ASSERT( p_map );\r
+ return( <a href="./cl_qmap_h.html#robo597">cl_qmap_count</a>( &p_map->qmap ) );\r
+}\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_map\r
+ [in] Pointer to a map whose item count to return.\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> Returns the number of items stored in the map.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> <a href="#robo17">Map</a>, <a href="#robo396">cl_is_map_empty</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo399">[Functions]<a name="Component20Library3a20Map2fcl5fmap5fdelta">\r
+Component Library: Map/cl_map_delta</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_map_delta</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_map_delta</strong> function computes the differences between two maps.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT <a href="./cl_types_h.html#robo304">cl_status_t</a> CL_API\r
+<strong>cl_map_delta</strong>(\r
+ IN OUT <a href="#robo415">cl_map_t</a>* const p_map1,\r
+ IN OUT <a href="#robo415">cl_map_t</a>* const p_map2,\r
+ OUT <a href="#robo415">cl_map_t</a>* const p_new,\r
+ OUT <a href="#robo415">cl_map_t</a>* const p_old );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_map1\r
+ [in/out] Pointer to the first of two <a href="#robo415">cl_map_t</a> structures whose\r
+ differences to compute.\r
+\r
+ p_map2\r
+ [in/out] Pointer to the second of two <a href="#robo415">cl_map_t</a> structures whose\r
+ differences to compute.\r
+\r
+ p_new\r
+ [out] Pointer to an empty <a href="#robo415">cl_map_t</a> structure that contains the items\r
+ unique to p_map2 upon return from the function.\r
+\r
+ p_old\r
+ [out] Pointer to an empty <a href="#robo415">cl_map_t</a> structure that contains the items\r
+ unique to p_map1 upon return from the function.\r
+\r
+ RETURN VALUES\r
+ CL_SUCCESS if the operation succeeded.\r
+\r
+ CL_INSUFFICIENT_MEMORY if there was not enough memory for the operation\r
+ to succeed.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> Items are evaluated based on their keys. Items that exist in both\r
+ p_map1 and p_map2 remain in their respective maps. Items that\r
+ exist only p_map1 are moved to p_old. Likewise, items that exist only\r
+ in p_map2 are moved to p_new. This function can be usefull in evaluating\r
+ changes between two maps.\r
+\r
+ Both maps pointed to by p_new and p_old must be empty on input.\r
+\r
+ Upon failure, all input maps are restored to their original state.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> <a href="#robo17">Map</a>, <a href="#robo408">cl_map_merge</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo400">[Functions]<a name="Component20Library3a20Map2fcl5fmap5fdestroy">\r
+Component Library: Map/cl_map_destroy</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_map_destroy</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_map_destroy</strong> function destroys a map.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT void CL_API\r
+<strong>cl_map_destroy</strong>(\r
+ IN <a href="#robo415">cl_map_t</a>* const p_map );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_map\r
+ [in] Pointer to a map to destroy.\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> This function does not return a value.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> Performs any necessary cleanup of the specified map. Further\r
+ operations should not be attempted on the map. <strong>cl_map_destroy</strong> does\r
+ not affect any of the objects stored in the map.\r
+ This function should only be called after a call to <a href="#robo397">cl_map_construct</a>.\r
+\r
+ In debug builds, <strong>cl_map_destroy</strong> asserts that the map is empty.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> <a href="#robo17">Map</a>, <a href="#robo397">cl_map_construct</a>, <a href="#robo404">cl_map_init</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo401">[Functions]<a name="Component20Library3a20Map2fcl5fmap5fend">\r
+Component Library: Map/cl_map_end</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_map_end</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_map_end</strong> function returns the iterator for the end of a map.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_INLINE const <a href="#robo406">cl_map_iterator_t</a> CL_API\r
+<strong>cl_map_end</strong>(\r
+ IN const <a href="#robo415">cl_map_t</a>* const p_map )\r
+{\r
+ CL_ASSERT( p_map );\r
+ return( <a href="./cl_qmap_h.html#robo599">cl_qmap_end</a>( &p_map->qmap ) );\r
+}\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_map\r
+ [in] Pointer to a <a href="#robo415">cl_map_t</a> structure whose end to return.\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> Iterator for the end of the map.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> <strong>cl_map_end</strong> is useful for determining the validity of map items returned\r
+ by <a href="#robo403">cl_map_head</a>, <a href="#robo416">cl_map_tail</a>, <a href="#robo409">cl_map_next</a>, <a href="#robo411">cl_map_prev</a>. If the iterator\r
+ by any of these functions compares to the end, the end of the map was\r
+ encoutered.\r
+ When using <a href="#robo403">cl_map_head</a> or <a href="#robo416">cl_map_tail</a>, this condition indicates that\r
+ the map is empty.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> <a href="#robo17">Map</a>, <a href="./cl_qmap_h.html#robo601">cl_qmap_head</a>, <a href="./cl_qmap_h.html#robo614">cl_qmap_tail</a>, <a href="./cl_qmap_h.html#robo606">cl_qmap_next</a>, <a href="./cl_qmap_h.html#robo608">cl_qmap_prev</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo402">[Functions]<a name="Component20Library3a20Map2fcl5fmap5fget">\r
+Component Library: Map/cl_map_get</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_map_get</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_map_get</strong> function returns the object associated with a key.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT void* CL_API\r
+<strong>cl_map_get</strong>(\r
+ IN const <a href="#robo415">cl_map_t</a>* const p_map,\r
+ IN const uint64_t key );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_map\r
+ [in] Pointer to a map from which to retrieve the object with\r
+ the specified key.\r
+\r
+ key\r
+ [in] Key value used to search for the desired object.\r
+\r
+ RETURN VALUES\r
+ Pointer to the object with the desired key value.\r
+\r
+ NULL if there was no item with the desired key value stored in\r
+ the map.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> <strong>cl_map_get</strong> does not remove the item from the map.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> <a href="#robo17">Map</a>, <a href="#robo412">cl_map_remove</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo403">[Functions]<a name="Component20Library3a20Map2fcl5fmap5fhead">\r
+Component Library: Map/cl_map_head</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_map_head</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_map_head</strong> function returns the map item with the lowest key\r
+ value stored in a map.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_INLINE <a href="#robo406">cl_map_iterator_t</a> CL_API\r
+<strong>cl_map_head</strong>(\r
+ IN const <a href="#robo415">cl_map_t</a>* const p_map )\r
+{\r
+ CL_ASSERT( p_map );\r
+ return( <a href="./cl_qmap_h.html#robo601">cl_qmap_head</a>( &p_map->qmap ) );\r
+}\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_map\r
+ [in] Pointer to a map whose item with the lowest key is returned.\r
+\r
+ RETURN VALUES\r
+ Iterator for the object with the lowest key in the map.\r
+\r
+ Iterator for the map end if the map was empty.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> <strong>cl_map_head</strong> does not remove the object from the map.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> <a href="#robo17">Map</a>, <a href="#robo416">cl_map_tail</a>, <a href="#robo409">cl_map_next</a>, <a href="#robo411">cl_map_prev</a>, <a href="#robo401">cl_map_end</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo404">[Functions]<a name="Component20Library3a20Map2fcl5fmap5finit">\r
+Component Library: Map/cl_map_init</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_map_init</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_map_init</strong> function initialized a map for use.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT <a href="./cl_types_h.html#robo304">cl_status_t</a> CL_API\r
+<strong>cl_map_init</strong>(\r
+ IN <a href="#robo415">cl_map_t</a>* const p_map,\r
+ IN const size_t min_items );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_map\r
+ [in] Pointer to a <a href="#robo415">cl_map_t</a> structure to initialize.\r
+\r
+ min_items\r
+ [in] Minimum number of items that can be stored. All necessary\r
+ allocations to allow storing the minimum number of items is performed\r
+ at initialization time.\r
+\r
+ RETURN VALUES\r
+ CL_SUCCESS if the map was initialized successfully.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> Allows calling map manipulation functions.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> <a href="#robo17">Map</a>, <a href="#robo400">cl_map_destroy</a>, <a href="#robo405">cl_map_insert</a>, <a href="#robo412">cl_map_remove</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo405">[Functions]<a name="Component20Library3a20Map2fcl5fmap5finsert">\r
+Component Library: Map/cl_map_insert</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_map_insert</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_map_insert</strong> function inserts a map item into a map.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT void* CL_API\r
+<strong>cl_map_insert</strong>(\r
+ IN <a href="#robo415">cl_map_t</a>* const p_map,\r
+ IN const uint64_t key,\r
+ IN const void* const p_object );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_map\r
+ [in] Pointer to a map into which to add the item.\r
+\r
+ key\r
+ [in] Value to associate with the object.\r
+\r
+ p_object\r
+ [in] Pointer to an object to insert into the map.\r
+\r
+ RETURN VALUES\r
+ Pointer to the object in the map with the specified key after the call\r
+ completes.\r
+\r
+ NULL if there was not enough memory to insert the desired item.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> Insertion operations may cause the map to rebalance.\r
+\r
+ If the map already contains an object already with the specified key,\r
+ that object will not be replaced and the pointer to that object is\r
+ returned.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> <a href="#robo17">Map</a>, <a href="#robo412">cl_map_remove</a>, <a href="./cl_qmap_h.html#robo593">cl_map_item_t</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo406">[Definitions]<a name="Component20Library3a20Map2fcl5fmap5fiterator5ft">\r
+Component Library: Map/cl_map_iterator_t</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_definitions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_map_iterator_t</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> Iterator type used to walk a map.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>typedef const <a href="./cl_qmap_h.html#robo593">cl_map_item_t</a> *<strong>cl_map_iterator_t</strong>;\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> The iterator should be treated as opaque to prevent corrupting the map.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> <a href="#robo17">Map</a>, <a href="#robo403">cl_map_head</a>, <a href="#robo416">cl_map_tail</a>, <a href="#robo409">cl_map_next</a>, <a href="#robo411">cl_map_prev</a>, <a href="#robo407">cl_map_key</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo407">[Functions]<a name="Component20Library3a20Map2fcl5fmap5fkey">\r
+Component Library: Map/cl_map_key</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_map_key</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_map_key</strong> function retrieves the key value of a map item.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_INLINE uint64_t CL_API\r
+<strong>cl_map_key</strong>(\r
+ IN const <a href="#robo406">cl_map_iterator_t</a> itor )\r
+{\r
+ return( <a href="./cl_qmap_h.html#robo604">cl_qmap_key</a>( itor ) );\r
+}\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> itor\r
+ [in] Iterator for the item whose key to return.\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> Returns the 64-bit key value for the specified iterator.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> The iterator specified by the itor parameter must have been retrived by\r
+ a previous call to <a href="#robo403">cl_map_head</a>, <a href="#robo416">cl_map_tail</a>, <a href="#robo409">cl_map_next</a>, or <a href="#robo411">cl_map_prev</a>.\r
+\r
+ The key value is set in a call to <a href="#robo405">cl_map_insert</a>.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> <a href="#robo17">Map</a>, <a href="#robo405">cl_map_insert</a>, <a href="#robo403">cl_map_head</a>, <a href="#robo416">cl_map_tail</a>, <a href="#robo409">cl_map_next</a>, <a href="#robo411">cl_map_prev</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo408">[Functions]<a name="Component20Library3a20Map2fcl5fmap5fmerge">\r
+Component Library: Map/cl_map_merge</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_map_merge</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_map_merge</strong> function moves all items from one map to another,\r
+ excluding duplicates.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT <a href="./cl_types_h.html#robo304">cl_status_t</a> CL_API\r
+<strong>cl_map_merge</strong>(\r
+ OUT <a href="#robo415">cl_map_t</a>* const p_dest_map,\r
+ IN OUT <a href="#robo415">cl_map_t</a>* const p_src_map );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_dest_map\r
+ [out] Pointer to a <a href="#robo415">cl_map_t</a> structure to which items should be added.\r
+\r
+ p_src_map\r
+ [in/out] Pointer to a <a href="#robo415">cl_map_t</a> structure whose items to add\r
+ to p_dest_map.\r
+\r
+ RETURN VALUES\r
+ CL_SUCCESS if the operation succeeded.\r
+\r
+ CL_INSUFFICIENT_MEMORY if there was not enough memory for the operation\r
+ to succeed.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> Items are evaluated based on their keys only.\r
+\r
+ Upon return from <strong>cl_map_merge</strong>, the map referenced by p_src_map contains\r
+ all duplicate items.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> <a href="#robo17">Map</a>, <a href="#robo399">cl_map_delta</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo409">[Functions]<a name="Component20Library3a20Map2fcl5fmap5fnext">\r
+Component Library: Map/cl_map_next</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_map_next</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_map_next</strong> function returns the map item with the next higher\r
+ key value than a specified map item.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_INLINE <a href="#robo406">cl_map_iterator_t</a> CL_API\r
+<strong>cl_map_next</strong>(\r
+ IN const <a href="#robo406">cl_map_iterator_t</a> itor )\r
+{\r
+ CL_ASSERT( itor );\r
+ return( <a href="./cl_qmap_h.html#robo606">cl_qmap_next</a>( itor ) );\r
+}\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> itor\r
+ [in] Iterator for an object in a map whose successor to return.\r
+\r
+ RETURN VALUES\r
+ Iterator for the object with the next higher key value in a map.\r
+\r
+ Iterator for the map end if the specified object was the last item in\r
+ the map.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> The iterator must have been retrieved by a previous call to <a href="#robo403">cl_map_head</a>,\r
+ <a href="#robo416">cl_map_tail</a>, <strong>cl_map_next</strong>, or <a href="#robo411">cl_map_prev</a>.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> <a href="#robo17">Map</a>, <a href="#robo403">cl_map_head</a>, <a href="#robo416">cl_map_tail</a>, <a href="#robo411">cl_map_prev</a>, <a href="#robo401">cl_map_end</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo410">[Functions]<a name="Component20Library3a20Map2fcl5fmap5fobj">\r
+Component Library: Map/cl_map_obj</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_map_obj</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_map_obj</strong> function returns the object associated with an iterator.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_INLINE void* CL_API\r
+<strong>cl_map_obj</strong>(\r
+ IN const <a href="#robo406">cl_map_iterator_t</a> itor )\r
+{\r
+ return( <a href="./cl_qmap_h.html#robo607">cl_qmap_obj</a>( <a href="./cl_types_h.html#robo508">PARENT_STRUCT</a>( itor, <a href="./cl_qmap_h.html#robo594">cl_map_obj_t</a>, item ) ) );\r
+}\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> itor\r
+ [in] Iterator whose object to return.\r
+\r
+ RETURN VALUES\r
+ Returns the value of the object pointer associated with the iterator.\r
+\r
+ The iterator must have been retrieved by a previous call to <a href="#robo403">cl_map_head</a>,\r
+ <a href="#robo416">cl_map_tail</a>, <a href="#robo409">cl_map_next</a>, or <a href="#robo411">cl_map_prev</a>.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> <a href="#robo17">Map</a>, <a href="#robo403">cl_map_head</a>, <a href="#robo416">cl_map_tail</a>, <a href="#robo409">cl_map_next</a>, <a href="#robo411">cl_map_prev</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo411">[Functions]<a name="Component20Library3a20Map2fcl5fmap5fprev">\r
+Component Library: Map/cl_map_prev</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_map_prev</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_map_prev</strong> function returns the map item with the next lower\r
+ key value than a precified map item.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_INLINE <a href="#robo406">cl_map_iterator_t</a> CL_API\r
+<strong>cl_map_prev</strong>(\r
+ IN const <a href="#robo406">cl_map_iterator_t</a> itor )\r
+{\r
+ CL_ASSERT( itor );\r
+ return( <a href="./cl_qmap_h.html#robo608">cl_qmap_prev</a>( itor ) );\r
+}\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> itor\r
+ [in] Iterator for an object in a map whose predecessor to return.\r
+\r
+ RETURN VALUES\r
+ Iterator for the object with the next lower key value in a map.\r
+\r
+ Iterator for the map end if the specified object was the first item in\r
+ the map.\r
+</pre>\r
+</span><p><strong>NOTES</strong></p>\r
+<span class="NOTES"><pre> The iterator must have been retrieved by a previous call to <a href="#robo403">cl_map_head</a>,\r
+ <a href="#robo416">cl_map_tail</a>, <a href="#robo409">cl_map_next</a>, or <strong>cl_map_prev</strong>.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> <a href="#robo17">Map</a>, <a href="#robo403">cl_map_head</a>, <a href="#robo416">cl_map_tail</a>, <a href="#robo409">cl_map_next</a>, <a href="#robo401">cl_map_end</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo412">[Functions]<a name="Component20Library3a20Map2fcl5fmap5fremove">\r
+Component Library: Map/cl_map_remove</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_map_remove</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_map_remove</strong> function removes the map item with the specified key\r
+ from a map.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT void* CL_API\r
+<strong>cl_map_remove</strong>(\r
+ IN <a href="#robo415">cl_map_t</a>* const p_map,\r
+ IN const uint64_t key );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_map\r
+ [in] Pointer to a <a href="#robo415">cl_map_t</a> structure from which to remove the item\r
+ with the specified key.\r
+\r
+ key\r
+ [in] Key value used to search for the object to remove.\r
+\r
+ RETURN VALUES\r
+ Pointer to the object associated with the specified key if\r
+ it was found and removed.\r
+\r
+ NULL if no object with the specified key exists in the map.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> <a href="#robo17">Map</a>, <a href="#robo414">cl_map_remove_item</a>, <a href="#robo413">cl_map_remove_all</a>, <a href="#robo405">cl_map_insert</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo413">[Functions]<a name="Component20Library3a20Map2fcl5fmap5fremove5fall">\r
+Component Library: Map/cl_map_remove_all</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_map_remove_all</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_map_remove_all</strong> function removes all objects from a map,\r
+ leaving it empty.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT void CL_API\r
+<strong>cl_map_remove_all</strong>(\r
+ IN <a href="#robo415">cl_map_t</a>* const p_map );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
+<span class="PARAMETERS"><pre> p_map\r
+ [in] Pointer to a map to empty.\r
+</pre>\r
+</span><p><strong>RETURN VALUE</strong></p>\r
+<span class="RETURN_VALUE"><pre> This function does not return a value.\r
+</pre>\r
+</span><p><strong>SEE ALSO</strong></p>\r
+<span class="SEE_ALSO"><pre> <a href="#robo17">Map</a>, <a href="#robo412">cl_map_remove</a>, <a href="#robo414">cl_map_remove_item</a>\r
+</pre>\r
+</span>\r
+<hr />\r
+\r
+<h2><a name="robo414">[Functions]<a name="Component20Library3a20Map2fcl5fmap5fremove5fitem">\r
+Component Library: Map/cl_map_remove_item</a></h2>\r
+\r
+<p>[<a href="#robo_top_of_doc">top</a>][<a href="../robo_functions.html#top">index</a>]</p>\r
+<p><strong>NAME</strong></p>\r
+<span class="NAME"><pre> <strong>cl_map_remove_item</strong>\r
+</pre>\r
+</span><p><strong>DESCRIPTION</strong></p>\r
+<span class="DESCRIPTION"><pre> The <strong>cl_map_remove_item</strong> function removes the specified map item\r
+ from a map.\r
+</pre>\r
+</span><p><strong>SYNOPSIS</strong></p>\r
+<span class="SYNOPSIS"><pre>CL_EXPORT void CL_API\r
+<strong>cl_map_remove_item</strong>(\r
+ IN <a href="#robo415">cl_map_t</a>* const p_map,\r
+ IN const <a href="#robo406">cl_map_iterator_t</a> itor );\r
+</pre>\r
+</span><p><strong>PARAMETERS</strong></p>\r
http://git.etherboot.org / mirror / winof / .git / commitdiff