TABLE OF CONTENTS

1. Component Library/Composite Pool
2. Component Library: Composite Pool/cl_cpool_construct
3. Component Library: Composite Pool/cl_cpool_count
4. Component Library: Composite Pool/cl_cpool_destroy
5. Component Library: Composite Pool/cl_cpool_get
6. Component Library: Composite Pool/cl_cpool_grow
7. Component Library: Composite Pool/cl_cpool_init
8. Component Library: Composite Pool/cl_cpool_put
9. Component Library: Composite Pool/cl_cpool_t
10. Component Library: Composite Pool/cl_is_cpool_inited
11. Component Library: Composite Pool/cl_pfn_cpool_dtor_t
12. Component Library: Composite Pool/cl_pfn_cpool_init_t

Component Library/Composite Pool

    Composite Pool

    The Composite Pool provides a self-contained and self-sustaining pool of
    user defined composite objects.

    A composite object is an object that is composed of one or more
    sub-objects, each of which needs to be treated separately for
    initialization. Objects can be retrieved from the pool as long as there
    is memory in the system.

    To aid in object oriented design, the composite pool provides the user
    the ability to specify callbacks that are invoked for each object for
    construction, initialization, and destruction. Constructor and destructor
    callback functions may not fail.

    A composite pool does not return memory to the system as the user returns
    objects to the pool. The only method of returning memory to the system is
    to destroy the pool.

    The composite pool functions operates on a cl_cpool_t structure which 
    should be treated as opaque and should be manipulated only through the 
    provided functions.

    Structures:
        cl_cpool_t

    Callbacks:
        cl_pfn_cpool_init_t, cl_pfn_cpool_dtor_t
    
    Initialization/Destruction:
        cl_cpool_construct, cl_cpool_init, cl_cpool_destroy

    Manipulation:
        cl_cpool_get, cl_cpool_put, cl_cpool_grow 

    Attributes:
        cl_is_cpool_inited, cl_cpool_count 

Component Library: Composite Pool/cl_cpool_construct

    cl_cpool_construct

    The cl_cpool_construct function constructs a composite pool.

void
cl_cpool_construct(
    IN  cl_cpool_t* const   p_pool );

    p_pool
        [in] Pointer to a cl_cpool_t structure whose state to initialize.

    This function does not return a value.

    Allows calling cl_pool_init, cl_cpool_destroy, cl_is_cpool_inited.

    Calling cl_cpool_construct is a prerequisite to calling any other
    composite pool function except cl_cpool_init.

    Composite Pool, cl_cpool_init, cl_cpool_destroy, cl_is_cpool_inited

Component Library: Composite Pool/cl_cpool_count

    cl_cpool_count

    The cl_cpool_count function returns the number of available objects
    in a composite pool.

 size_t
cl_cpool_count(
    IN  cl_cpool_t* const   p_pool ;

    p_pool
        [in] Pointer to a cl_cpool_t structure for which the number of
        available objects is requested.

    Returns the number of objects available in the specified
    composite pool.

    Composite Pool

Component Library: Composite Pool/cl_cpool_destroy

    cl_cpool_destroy

    The cl_cpool_destroy function destroys a composite pool.

 void
cl_cpool_destroy(
    IN  cl_cpool_t* const   p_pool ;

    p_pool
        [in] Pointer to a cl_cpool_t structure to destroy.

    This function does not return a value.

    All memory allocated for composite objects is freed. The destructor
    callback, if any, will be invoked for every allocated object. Further
    operations on the composite pool should not be attempted after
    cl_cpool_destroy is invoked.

    This function should only be called after a call to cl_cpool_construct.

    In a debug build, cl_cpool_destroy asserts that all objects are in
    the pool.

    Composite Pool, cl_cpool_construct, cl_cpool_init

Component Library: Composite Pool/cl_cpool_get

    cl_cpool_get

    The cl_cpool_get function retrieves an object from a
    composite pool.

 void*
cl_cpool_get(
    IN  cl_cpool_t* const   p_pool ;

    p_pool
        [in] Pointer to a cl_cpool_t structure from which to retrieve
        an object.

    Returns a pointer to the first component of a composite object.

    Returns NULL if the pool is empty and can not be grown automatically.

    cl_cpool_get returns the object at the head of the pool. If the pool is
    empty, it is automatically grown to accommodate this request unless the
    grow_size parameter passed to the cl_cpool_init function was zero.

    Composite Pool, cl_cpool_get_tail, cl_cpool_put, cl_cpool_grow,
    cl_cpool_count

Component Library: Composite Pool/cl_cpool_grow

    cl_cpool_grow

    The cl_cpool_grow function grows a composite pool by
    the specified number of objects.

 cl_status_t
cl_cpool_grow(
    IN  cl_cpool_t* const   p_pool,
    IN  const uint32_t          obj_count ;

    p_pool
        [in] Pointer to a cl_cpool_t structure whose capacity to grow.

    obj_count
        [in] Number of objects by which to grow the pool.

    CL_SUCCESS if the composite pool grew successfully.

    CL_INSUFFICIENT_MEMORY if there was not enough memory to grow the
    composite pool.

    cl_status_t value returned by optional initialization callback function
    specified by the pfn_initializer parameter passed to the
    cl_cpool_init function.

    It is not necessary to call cl_cpool_grow if the pool is
    configured to grow automatically.

    Composite Pool

Component Library: Composite Pool/cl_cpool_init

    cl_cpool_init

    The cl_cpool_init function initializes a composite pool for use.

cl_status_t
cl_cpool_init(
    IN  cl_cpool_t* const       p_pool,
    IN  const size_t            min_size,
    IN  const size_t            max_size,
    IN  const size_t            grow_size,
    IN  size_t* const           component_sizes,
    IN  const uint32_t          num_components,
    IN  cl_pfn_cpool_init_t     pfn_initializer OPTIONAL,
    IN  cl_pfn_cpool_dtor_t     pfn_destructor OPTIONAL,
    IN  const void* const       context );

    p_pool
        [in] Pointer to a cl_cpool_t structure to initialize.

    min_size
        [in] Minimum number of objects that the pool should support. All
        necessary allocations to allow storing the minimum number of items
        are performed at initialization time, and all necessary callbacks
        successfully invoked.

    max_size
        [in] Maximum number of objects to which the pool is allowed to grow.
        A value of zero specifies no maximum.

    grow_size
        [in] Number of objects to allocate when incrementally growing the pool.
        A value of zero disables automatic growth.

    component_sizes
        [in] Pointer to the first entry in an array of sizes describing,
        in order, the sizes of the components that make up a composite object.

    num_components
        [in] Number of components that make up a composite object.

    pfn_initializer
        [in] Initialization callback to invoke for every new object when
        growing the pool. This parameter may be NULL only if the objects
        stored in the composite pool consist of only one component.
        See the cl_pfn_cpool_init function type declaration for details
        about the callback function.

    pfn_destructor
        [in] Destructor callback to invoke for every object before memory for
        that object is freed. This parameter is optional and may be NULL.
        See the cl_pfn_cpool_dtor function type declaration for details
        about the callback function.

    context
        [in] Value to pass to the callback functions to provide context.

    CL_SUCCESS if the composite pool was initialized successfully.

    CL_INSUFFICIENT_MEMORY if there was not enough memory to initialize the
    composite pool.

    CL_INVALID_SETTING if a NULL constructor was provided for composite objects
    consisting of more than one component.  Also returns CL_INVALID_SETTING if
    the maximum size is non-zero and less than the minimum size.

    Other cl_status_t value returned by optional initialization callback function
    specified by the pfn_initializer parameter.

    cl_cpool_init initializes, and if necessary, grows the pool to
    the capacity desired.

    Composite Pool, cl_cpool_construct, cl_cpool_destroy,
    cl_cpool_get, cl_cpool_put, cl_cpool_grow,
    cl_cpool_count, cl_pfn_cpool_ctor_t, cl_pfn_cpool_init_t,
    cl_pfn_cpool_dtor_t

Component Library: Composite Pool/cl_cpool_put

    cl_cpool_put

    The cl_cpool_put function returns an object to a composite pool.

 void
cl_cpool_put(
    IN  cl_cpool_t* const   p_pool,
    IN  void* const         p_object ;

    p_pool
        [in] Pointer to a cl_cpool_t structure to which to return
        an object.

    p_object
        [in] Pointer to the first component of an object to return to the pool.

    This function does not return a value.

    cl_cpool_put places the returned object at the head of the pool.

    The object specified by the p_object parameter must have been
    retrieved from the pool by a previous call to cl_cpool_get.

    Composite Pool, cl_cpool_put_tail, cl_cpool_get

Component Library: Composite Pool/cl_cpool_t

    cl_cpool_t

    Composite pool structure.

    The cl_cpool_t structure should be treated as opaque and should be
    manipulated only through the provided functions.

typedef struct _cl_cpool
{
    cl_qcpool_t             qcpool;
    cl_pfn_cpool_init_t     pfn_init;
    cl_pfn_cpool_dtor_t     pfn_dtor;
    const void              *context;

} cl_cpool_t;

    qcpool
        Quick composite pool that manages all objects.

    pfn_init
        Pointer to the user's initializer callback, used by the pool
        to translate the quick composite pool's initializer callback to
        a composite pool initializer callback.

    pfn_dtor
        Pointer to the user's destructor callback, used by the pool
        to translate the quick composite pool's destructor callback to
        a composite pool destructor callback.

    context
        User's provided context for callback functions, used by the pool
        to when invoking callbacks.

    Composite Pool

Component Library: Composite Pool/cl_is_cpool_inited

    cl_is_cpool_inited

    The cl_is_cpool_inited function returns whether a composite pool was
    successfully initialized.

 boolean_t
cl_is_cpool_inited(
    IN  const cl_cpool_t* const p_pool ;

    p_pool
        [in] Pointer to a cl_cpool_t structure whose initialization state
        to check.

    TRUE if the composite pool was initialized successfully.

    FALSE otherwise.

    Allows checking the state of a composite pool to determine if invoking
    member functions is appropriate.

    Composite Pool

Component Library: Composite Pool/cl_pfn_cpool_dtor_t

    cl_pfn_cpool_dtor_t

    The cl_pfn_cpool_dtor_t function type defines the prototype for
    functions used as destructor for objects being deallocated by a
    composite pool.

typedef void
(*cl_pfn_cpool_dtor_t)(
    IN  void* const         p_object,
    IN  void*               context );

    p_object
        [in] Pointer to an object to destruct.

    context
        [in] Context provided in the call to cl_cpool_init.

    This function does not return a value.

    This function type is provided as function prototype reference for
    the function provided by the user as an optional parameter to the
    cl_cpool_init function.

    The destructor is invoked once per allocated object, allowing the user
    to perform any necessary cleanup. Users should not attempt to deallocate
    the memory for the composite object, as the composite pool manages
    object allocation and deallocation.

    Composite Pool, cl_cpool_init

Component Library: Composite Pool/cl_pfn_cpool_init_t

    cl_pfn_cpool_init_t

    The cl_pfn_cpool_init_t function type defines the prototype for
    functions used as initializers for objects being allocated by a
    composite pool.

typedef cl_status_t
(*cl_pfn_cpool_init_t)(
    IN  void** const        p_comp_array,
    IN  const uint32_t      num_components,
    IN  void*               context );

    p_object
        [in] Pointer to an object to initialize.

    context
        [in] Context provided in a call to cl_cpool_init.

    Return CL_SUCCESS to indicates that initialization of the object
    was successful and that initialization of further objects may continue.

    Other cl_status_t values will be returned by cl_cpool_init
    and cl_cpool_grow.

    This function type is provided as function prototype reference for
    the function provided by the user as an optional parameter to the
    cl_cpool_init function.

    The initializer is invoked once per allocated object, allowing the user
    to chain components to form a composite object and perform any necessary
    initialization.  Returning a status other than CL_SUCCESS aborts a grow
    operation, initiated either through cl_cpool_init or cl_cpool_grow, and
    causes the initiating function to fail.  Any non-CL_SUCCESS status will
    be returned by the function that initiated the grow operation.

    All memory for the requested number of components is pre-allocated.

    When later performing a cl_cpool_get call, the return value is a pointer
    to the first component.

    Composite Pool, cl_cpool_init, cl_cpool_grow