@@ -213,592 +214,500 @@
00189 apr_allocator_t *allocator);
00190
00191 /**
-00192 * Create a new pool.
-00193 * @deprecated @see apr_pool_create_unmanaged_ex.
-00194 */
-00195 APR_DECLARE(apr_status_t) apr_pool_create_core_ex(apr_pool_t **newpool,
-00196 apr_abortfunc_t abort_fn,
-00197 apr_allocator_t *allocator);
-00198
-00199 /**
-00200 * Create a new unmanaged pool.
-00201 * @param newpool The pool we have just created.
-00202 * @param abort_fn A function to use if the pool cannot allocate more memory.
-00203 * @param allocator The allocator to use with the new pool. If NULL a
-00204 * new allocator will be crated with newpool as owner.
-00205 * @remark An unmanaged pool is a special pool without a parent; it will
-00206 * NOT be destroyed upon apr_terminate. It must be explicitly
-00207 * destroyed by calling apr_pool_destroy, to prevent memory leaks.
-00208 * Use of this function is discouraged, think twice about whether
-00209 * you really really need it.
-00210 */
-00211 APR_DECLARE(apr_status_t) apr_pool_create_unmanaged_ex(apr_pool_t **newpool,
-00212 apr_abortfunc_t abort_fn,
-00213 apr_allocator_t *allocator);
-00214
-00215 /**
-00216 * Debug version of apr_pool_create_ex.
-00217 * @param newpool @see apr_pool_create.
-00218 * @param parent @see apr_pool_create.
-00219 * @param abort_fn @see apr_pool_create.
-00220 * @param allocator @see apr_pool_create.
-00221 * @param file_line Where the function is called from.
-00222 * This is usually APR_POOL__FILE_LINE__.
-00223 * @remark Only available when APR_POOL_DEBUG is defined.
-00224 * Call this directly if you have you apr_pool_create_ex
-00225 * calls in a wrapper function and wish to override
-00226 * the file_line argument to reflect the caller of
-00227 * your wrapper function. If you do not have
-00228 * apr_pool_create_ex in a wrapper, trust the macro
-00229 * and don't call apr_pool_create_ex_debug directly.
-00230 */
-00231 APR_DECLARE(apr_status_t) apr_pool_create_ex_debug(apr_pool_t **newpool,
-00232 apr_pool_t *parent,
-00233 apr_abortfunc_t abort_fn,
-00234 apr_allocator_t *allocator,
-00235 const char *file_line);
-00236
-00237 #if APR_POOL_DEBUG
-00238 #define apr_pool_create_ex(newpool, parent, abort_fn, allocator) \
-00239 apr_pool_create_ex_debug(newpool, parent, abort_fn, allocator, \
-00240 APR_POOL__FILE_LINE__)
-00241 #endif
-00242
-00243 /**
-00244 * Debug version of apr_pool_create_core_ex.
-00245 * @deprecated @see apr_pool_create_unmanaged_ex_debug.
-00246 */
-00247 APR_DECLARE(apr_status_t) apr_pool_create_core_ex_debug(apr_pool_t **newpool,
-00248 apr_abortfunc_t abort_fn,
-00249 apr_allocator_t *allocator,
-00250 const char *file_line);
+00192 * Debug version of apr_pool_create_ex.
+00193 * @param newpool @see apr_pool_create.
+00194 * @param parent @see apr_pool_create.
+00195 * @param abort_fn @see apr_pool_create.
+00196 * @param allocator @see apr_pool_create.
+00197 * @param file_line Where the function is called from.
+00198 * This is usually APR_POOL__FILE_LINE__.
+00199 * @remark Only available when APR_POOL_DEBUG is defined.
+00200 * Call this directly if you have you apr_pool_create_ex
+00201 * calls in a wrapper function and wish to override
+00202 * the file_line argument to reflect the caller of
+00203 * your wrapper function. If you do not have
+00204 * apr_pool_create_ex in a wrapper, trust the macro
+00205 * and don't call apr_pool_create_ex_debug directly.
+00206 */
+00207 APR_DECLARE(apr_status_t) apr_pool_create_ex_debug(apr_pool_t **newpool,
+00208 apr_pool_t *parent,
+00209 apr_abortfunc_t abort_fn,
+00210 apr_allocator_t *allocator,
+00211 const char *file_line);
+00212
+00213 #if APR_POOL_DEBUG
+00214 #define apr_pool_create_ex(newpool, parent, abort_fn, allocator) \
+00215 apr_pool_create_ex_debug(newpool, parent, abort_fn, allocator, \
+00216 APR_POOL__FILE_LINE__)
+00217 #endif
+00218
+00219 /**
+00220 * Create a new pool.
+00221 * @param newpool The pool we have just created.
+00222 * @param parent The parent pool. If this is NULL, the new pool is a root
+00223 * pool. If it is non-NULL, the new pool will inherit all
+00224 * of its parent pool's attributes, except the apr_pool_t will
+00225 * be a sub-pool.
+00226 */
+00227 #if defined(DOXYGEN)
+00228 APR_DECLARE(apr_status_t) apr_pool_create(apr_pool_t **newpool,
+00229 apr_pool_t *parent);
+00230 #else
+00231 #if APR_POOL_DEBUG
+00232 #define apr_pool_create(newpool, parent) \
+00233 apr_pool_create_ex_debug(newpool, parent, NULL, NULL, \
+00234 APR_POOL__FILE_LINE__)
+00235 #else
+00236 #define apr_pool_create(newpool, parent) \
+00237 apr_pool_create_ex(newpool, parent, NULL, NULL)
+00238 #endif
+00239 #endif
+00240
+00241
+00242 /**
+00243 * Clear all memory in the pool and run all the cleanups. This also destroys all
+00244 * subpools.
+00245 * @param p The pool to clear
+00246 * @remark This does not actually free the memory, it just allows the pool
+00247 * to re-use this memory for the next allocation.
+00248 * @see apr_pool_destroy()
+00249 */
+00250 APR_DECLARE(void) apr_pool_clear(apr_pool_t *p);
00251
00252 /**
-00253 * Debug version of apr_pool_create_unmanaged_ex.
-00254 * @param newpool @see apr_pool_create_unmanaged.
-00255 * @param abort_fn @see apr_pool_create_unmanaged.
-00256 * @param allocator @see apr_pool_create_unmanaged.
-00257 * @param file_line Where the function is called from.
-00258 * This is usually APR_POOL__FILE_LINE__.
-00259 * @remark Only available when APR_POOL_DEBUG is defined.
-00260 * Call this directly if you have you apr_pool_create_unmanaged_ex
-00261 * calls in a wrapper function and wish to override
-00262 * the file_line argument to reflect the caller of
-00263 * your wrapper function. If you do not have
-00264 * apr_pool_create_core_ex in a wrapper, trust the macro
-00265 * and don't call apr_pool_create_core_ex_debug directly.
-00266 */
-00267 APR_DECLARE(apr_status_t) apr_pool_create_unmanaged_ex_debug(apr_pool_t **newpool,
-00268 apr_abortfunc_t abort_fn,
-00269 apr_allocator_t *allocator,
-00270 const char *file_line);
-00271
-00272 #if APR_POOL_DEBUG
-00273 #define apr_pool_create_core_ex(newpool, abort_fn, allocator) \
-00274 apr_pool_create_unmanaged_ex_debug(newpool, abort_fn, allocator, \
-00275 APR_POOL__FILE_LINE__)
-00276
-00277 #define apr_pool_create_unmanaged_ex(newpool, abort_fn, allocator) \
-00278 apr_pool_create_unmanaged_ex_debug(newpool, abort_fn, allocator, \
-00279 APR_POOL__FILE_LINE__)
-00280
-00281 #endif
-00282
-00283 /**
-00284 * Create a new pool.
-00285 * @param newpool The pool we have just created.
-00286 * @param parent The parent pool. If this is NULL, the new pool is a root
-00287 * pool. If it is non-NULL, the new pool will inherit all
-00288 * of its parent pool's attributes, except the apr_pool_t will
-00289 * be a sub-pool.
-00290 */
-00291 #if defined(DOXYGEN)
-00292 APR_DECLARE(apr_status_t) apr_pool_create(apr_pool_t **newpool,
-00293 apr_pool_t *parent);
-00294 #else
-00295 #if APR_POOL_DEBUG
-00296 #define apr_pool_create(newpool, parent) \
-00297 apr_pool_create_ex_debug(newpool, parent, NULL, NULL, \
-00298 APR_POOL__FILE_LINE__)
-00299 #else
-00300 #define apr_pool_create(newpool, parent) \
-00301 apr_pool_create_ex(newpool, parent, NULL, NULL)
-00302 #endif
-00303 #endif
-00304
-00305 /**
-00306 * Create a new pool.
-00307 * @param newpool The pool we have just created.
-00308 */
-00309 #if defined(DOXYGEN)
-00310 APR_DECLARE(apr_status_t) apr_pool_create_core(apr_pool_t **newpool);
-00311 APR_DECLARE(apr_status_t) apr_pool_create_unmanaged(apr_pool_t **newpool);
-00312 #else
-00313 #if APR_POOL_DEBUG
-00314 #define apr_pool_create_core(newpool) \
-00315 apr_pool_create_unmanaged_ex_debug(newpool, NULL, NULL, \
-00316 APR_POOL__FILE_LINE__)
-00317 #define apr_pool_create_unmanaged(newpool) \
-00318 apr_pool_create_unmanaged_ex_debug(newpool, NULL, NULL, \
-00319 APR_POOL__FILE_LINE__)
-00320 #else
-00321 #define apr_pool_create_core(newpool) \
-00322 apr_pool_create_unmanaged_ex(newpool, NULL, NULL)
-00323 #define apr_pool_create_unmanaged(newpool) \
-00324 apr_pool_create_unmanaged_ex(newpool, NULL, NULL)
-00325 #endif
-00326 #endif
-00327
-00328 /**
-00329 * Find the pools allocator
-00330 * @param pool The pool to get the allocator from.
-00331 */
-00332 APR_DECLARE(apr_allocator_t *) apr_pool_allocator_get(apr_pool_t *pool);
-00333
-00334 /**
-00335 * Clear all memory in the pool and run all the cleanups. This also destroys all
-00336 * subpools.
-00337 * @param p The pool to clear
-00338 * @remark This does not actually free the memory, it just allows the pool
-00339 * to re-use this memory for the next allocation.
-00340 * @see apr_pool_destroy()
-00341 */
-00342 APR_DECLARE(void) apr_pool_clear(apr_pool_t *p);
-00343
-00344 /**
-00345 * Debug version of apr_pool_clear.
-00346 * @param p See: apr_pool_clear.
+00253 * Debug version of apr_pool_clear.
+00254 * @param p See: apr_pool_clear.
+00255 * @param file_line Where the function is called from.
+00256 * This is usually APR_POOL__FILE_LINE__.
+00257 * @remark Only available when APR_POOL_DEBUG is defined.
+00258 * Call this directly if you have you apr_pool_clear
+00259 * calls in a wrapper function and wish to override
+00260 * the file_line argument to reflect the caller of
+00261 * your wrapper function. If you do not have
+00262 * apr_pool_clear in a wrapper, trust the macro
+00263 * and don't call apr_pool_destroy_clear directly.
+00264 */
+00265 APR_DECLARE(void) apr_pool_clear_debug(apr_pool_t *p,
+00266 const char *file_line);
+00267
+00268 #if APR_POOL_DEBUG
+00269 #define apr_pool_clear(p) \
+00270 apr_pool_clear_debug(p, APR_POOL__FILE_LINE__)
+00271 #endif
+00272
+00273 /**
+00274 * Destroy the pool. This takes similar action as apr_pool_clear() and then
+00275 * frees all the memory.
+00276 * @param p The pool to destroy
+00277 * @remark This will actually free the memory
+00278 */
+00279 APR_DECLARE(void) apr_pool_destroy(apr_pool_t *p);
+00280
+00281 /**
+00282 * Debug version of apr_pool_destroy.
+00283 * @param p See: apr_pool_destroy.
+00284 * @param file_line Where the function is called from.
+00285 * This is usually APR_POOL__FILE_LINE__.
+00286 * @remark Only available when APR_POOL_DEBUG is defined.
+00287 * Call this directly if you have you apr_pool_destroy
+00288 * calls in a wrapper function and wish to override
+00289 * the file_line argument to reflect the caller of
+00290 * your wrapper function. If you do not have
+00291 * apr_pool_destroy in a wrapper, trust the macro
+00292 * and don't call apr_pool_destroy_debug directly.
+00293 */
+00294 APR_DECLARE(void) apr_pool_destroy_debug(apr_pool_t *p,
+00295 const char *file_line);
+00296
+00297 #if APR_POOL_DEBUG
+00298 #define apr_pool_destroy(p) \
+00299 apr_pool_destroy_debug(p, APR_POOL__FILE_LINE__)
+00300 #endif
+00301
+00302
+00303 /*
+00304 * Memory allocation
+00305 */
+00306
+00307 /**
+00308 * Allocate a block of memory from a pool
+00309 * @param p The pool to allocate from
+00310 * @param size The amount of memory to allocate
+00311 * @return The allocated memory
+00312 */
+00313 APR_DECLARE(void *) apr_palloc(apr_pool_t *p, apr_size_t size);
+00314
+00315 /**
+00316 * Debug version of apr_palloc
+00317 * @param p See: apr_palloc
+00318 * @param size See: apr_palloc
+00319 * @param file_line Where the function is called from.
+00320 * This is usually APR_POOL__FILE_LINE__.
+00321 * @return See: apr_palloc
+00322 */
+00323 APR_DECLARE(void *) apr_palloc_debug(apr_pool_t *p, apr_size_t size,
+00324 const char *file_line);
+00325
+00326 #if APR_POOL_DEBUG
+00327 #define apr_palloc(p, size) \
+00328 apr_palloc_debug(p, size, APR_POOL__FILE_LINE__)
+00329 #endif
+00330
+00331 /**
+00332 * Allocate a block of memory from a pool and set all of the memory to 0
+00333 * @param p The pool to allocate from
+00334 * @param size The amount of memory to allocate
+00335 * @return The allocated memory
+00336 */
+00337 #if defined(DOXYGEN)
+00338 APR_DECLARE(void *) apr_pcalloc(apr_pool_t *p, apr_size_t size);
+00339 #elif !APR_POOL_DEBUG
+00340 #define apr_pcalloc(p, size) memset(apr_palloc(p, size), 0, size)
+00341 #endif
+00342
+00343 /**
+00344 * Debug version of apr_pcalloc
+00345 * @param p See: apr_pcalloc
+00346 * @param size See: apr_pcalloc00347 * @param file_line Where the function is called from.00348 * This is usually APR_POOL__FILE_LINE__.
-00349 * @remark Only available when APR_POOL_DEBUG is defined.
-00350 * Call this directly if you have you apr_pool_clear
-00351 * calls in a wrapper function and wish to override
-00352 * the file_line argument to reflect the caller of
-00353 * your wrapper function. If you do not have
-00354 * apr_pool_clear in a wrapper, trust the macro
-00355 * and don't call apr_pool_destroy_clear directly.
-00356 */
-00357 APR_DECLARE(void) apr_pool_clear_debug(apr_pool_t *p,
-00358 const char *file_line);
+00349 * @return See: apr_pcalloc
+00350 */
+00351 APR_DECLARE(void *) apr_pcalloc_debug(apr_pool_t *p, apr_size_t size,
+00352 const char *file_line);
+00353
+00354 #if APR_POOL_DEBUG
+00355 #define apr_pcalloc(p, size) \
+00356 apr_pcalloc_debug(p, size, APR_POOL__FILE_LINE__)
+00357 #endif
+00358
00359
-00360 #if APR_POOL_DEBUG
-00361 #define apr_pool_clear(p) \
-00362 apr_pool_clear_debug(p, APR_POOL__FILE_LINE__)
-00363 #endif
-00364
-00365 /**
-00366 * Destroy the pool. This takes similar action as apr_pool_clear() and then
-00367 * frees all the memory.
-00368 * @param p The pool to destroy
-00369 * @remark This will actually free the memory
-00370 */
-00371 APR_DECLARE(void) apr_pool_destroy(apr_pool_t *p);
-00372
-00373 /**
-00374 * Debug version of apr_pool_destroy.
-00375 * @param p See: apr_pool_destroy.
-00376 * @param file_line Where the function is called from.
-00377 * This is usually APR_POOL__FILE_LINE__.
-00378 * @remark Only available when APR_POOL_DEBUG is defined.
-00379 * Call this directly if you have you apr_pool_destroy
-00380 * calls in a wrapper function and wish to override
-00381 * the file_line argument to reflect the caller of
-00382 * your wrapper function. If you do not have
-00383 * apr_pool_destroy in a wrapper, trust the macro
-00384 * and don't call apr_pool_destroy_debug directly.
-00385 */
-00386 APR_DECLARE(void) apr_pool_destroy_debug(apr_pool_t *p,
-00387 const char *file_line);
-00388
-00389 #if APR_POOL_DEBUG
-00390 #define apr_pool_destroy(p) \
-00391 apr_pool_destroy_debug(p, APR_POOL__FILE_LINE__)
-00392 #endif
-00393
-00394
-00395 /*
-00396 * Memory allocation
-00397 */
-00398
-00399 /**
-00400 * Allocate a block of memory from a pool
-00401 * @param p The pool to allocate from
-00402 * @param size The amount of memory to allocate
-00403 * @return The allocated memory
-00404 */
-00405 APR_DECLARE(void *) apr_palloc(apr_pool_t *p, apr_size_t size);
-00406
-00407 /**
-00408 * Debug version of apr_palloc
-00409 * @param p See: apr_palloc
-00410 * @param size See: apr_palloc
-00411 * @param file_line Where the function is called from.
-00412 * This is usually APR_POOL__FILE_LINE__.
-00413 * @return See: apr_palloc
-00414 */
-00415 APR_DECLARE(void *) apr_palloc_debug(apr_pool_t *p, apr_size_t size,
-00416 const char *file_line);
-00417
-00418 #if APR_POOL_DEBUG
-00419 #define apr_palloc(p, size) \
-00420 apr_palloc_debug(p, size, APR_POOL__FILE_LINE__)
-00421 #endif
-00422
-00423 /**
-00424 * Allocate a block of memory from a pool and set all of the memory to 0
-00425 * @param p The pool to allocate from
-00426 * @param size The amount of memory to allocate
-00427 * @return The allocated memory
-00428 */
-00429 #if defined(DOXYGEN)
-00430 APR_DECLARE(void *) apr_pcalloc(apr_pool_t *p, apr_size_t size);
-00431 #elif !APR_POOL_DEBUG
-00432 #define apr_pcalloc(p, size) memset(apr_palloc(p, size), 0, size)
-00433 #endif
-00434
-00435 /**
-00436 * Debug version of apr_pcalloc
-00437 * @param p See: apr_pcalloc
-00438 * @param size See: apr_pcalloc
-00439 * @param file_line Where the function is called from.
-00440 * This is usually APR_POOL__FILE_LINE__.
-00441 * @return See: apr_pcalloc
-00442 */
-00443 APR_DECLARE(void *) apr_pcalloc_debug(apr_pool_t *p, apr_size_t size,
-00444 const char *file_line);
-00445
-00446 #if APR_POOL_DEBUG
-00447 #define apr_pcalloc(p, size) \
-00448 apr_pcalloc_debug(p, size, APR_POOL__FILE_LINE__)
-00449 #endif
-00450
-00451
-00452 /*
-00453 * Pool Properties
-00454 */
-00455
-00456 /**
-00457 * Set the function to be called when an allocation failure occurs.
-00458 * @remark If the program wants APR to exit on a memory allocation error,
-00459 * then this function can be called to set the callback to use (for
-00460 * performing cleanup and then exiting). If this function is not called,
-00461 * then APR will return an error and expect the calling program to
-00462 * deal with the error accordingly.
-00463 */
-00464 APR_DECLARE(void) apr_pool_abort_set(apr_abortfunc_t abortfunc,
-00465 apr_pool_t *pool);
-00466
-00467 /**
-00468 * Get the abort function associated with the specified pool.
-00469 * @param pool The pool for retrieving the abort function.
-00470 * @return The abort function for the given pool.
-00471 */
-00472 APR_DECLARE(apr_abortfunc_t) apr_pool_abort_get(apr_pool_t *pool);
+00360 /*
+00361 * Pool Properties
+00362 */
+00363
+00364 /**
+00365 * Set the function to be called when an allocation failure occurs.
+00366 * @remark If the program wants APR to exit on a memory allocation error,
+00367 * then this function can be called to set the callback to use (for
+00368 * performing cleanup and then exiting). If this function is not called,
+00369 * then APR will return an error and expect the calling program to
+00370 * deal with the error accordingly.
+00371 */
+00372 APR_DECLARE(void) apr_pool_abort_set(apr_abortfunc_t abortfunc,
+00373 apr_pool_t *pool);
+00374
+00375 /**
+00376 * Get the abort function associated with the specified pool.
+00377 * @param pool The pool for retrieving the abort function.
+00378 * @return The abort function for the given pool.
+00379 */
+00380 APR_DECLARE(apr_abortfunc_t) apr_pool_abort_get(apr_pool_t *pool);
+00381
+00382 /**
+00383 * Get the parent pool of the specified pool.
+00384 * @param pool The pool for retrieving the parent pool.
+00385 * @return The parent of the given pool.
+00386 */
+00387 APR_DECLARE(apr_pool_t *) apr_pool_parent_get(apr_pool_t *pool);
+00388
+00389 /**
+00390 * Determine if pool a is an ancestor of pool b.
+00391 * @param a The pool to search
+00392 * @param b The pool to search for
+00393 * @return True if a is an ancestor of b, NULL is considered an ancestor
+00394 * of all pools.
+00395 * @remark if compiled with APR_POOL_DEBUG, this function will also
+00396 * return true if A is a pool which has been guaranteed by the caller
+00397 * (using apr_pool_join) to have a lifetime at least as long as some
+00398 * ancestor of pool B.
+00399 */
+00400 APR_DECLARE(int) apr_pool_is_ancestor(apr_pool_t *a, apr_pool_t *b);
+00401
+00402 /**
+00403 * Tag a pool (give it a name)
+00404 * @param pool The pool to tag
+00405 * @param tag The tag
+00406 */
+00407 APR_DECLARE(void) apr_pool_tag(apr_pool_t *pool, const char *tag);
+00408
+00409
+00410 /*
+00411 * User data management
+00412 */
+00413
+00414 /**
+00415 * Set the data associated with the current pool
+00416 * @param data The user data associated with the pool.
+00417 * @param key The key to use for association
+00418 * @param cleanup The cleanup program to use to cleanup the data (NULL if none)
+00419 * @param pool The current pool
+00420 * @warning The data to be attached to the pool should have a life span
+00421 * at least as long as the pool it is being attached to.
+00422 *
+00423 * Users of APR must take EXTREME care when choosing a key to
+00424 * use for their data. It is possible to accidentally overwrite
+00425 * data by choosing a key that another part of the program is using.
+00426 * Therefore it is advised that steps are taken to ensure that unique
+00427 * keys are used for all of the userdata objects in a particular pool
+00428 * (the same key in two different pools or a pool and one of its
+00429 * subpools is okay) at all times. Careful namespace prefixing of
+00430 * key names is a typical way to help ensure this uniqueness.
+00431 *
+00432 */
+00433 APR_DECLARE(apr_status_t) apr_pool_userdata_set(
+00434 const void *data,
+00435 const char *key,
+00436 apr_status_t (*cleanup)(void *),
+00437 apr_pool_t *pool);
+00438
+00439 /**
+00440 * Set the data associated with the current pool
+00441 * @param data The user data associated with the pool.
+00442 * @param key The key to use for association
+00443 * @param cleanup The cleanup program to use to cleanup the data (NULL if none)
+00444 * @param pool The current pool
+00445 * @note same as apr_pool_userdata_set(), except that this version doesn't
+00446 * make a copy of the key (this function is useful, for example, when
+00447 * the key is a string literal)
+00448 * @warning This should NOT be used if the key could change addresses by
+00449 * any means between the apr_pool_userdata_setn() call and a
+00450 * subsequent apr_pool_userdata_get() on that key, such as if a
+00451 * static string is used as a userdata key in a DSO and the DSO could
+00452 * be unloaded and reloaded between the _setn() and the _get(). You
+00453 * MUST use apr_pool_userdata_set() in such cases.
+00454 * @warning More generally, the key and the data to be attached to the
+00455 * pool should have a life span at least as long as the pool itself.
+00456 *
+00457 */
+00458 APR_DECLARE(apr_status_t) apr_pool_userdata_setn(
+00459 const void *data,
+00460 const char *key,
+00461 apr_status_t (*cleanup)(void *),
+00462 apr_pool_t *pool);
+00463
+00464 /**
+00465 * Return the data associated with the current pool.
+00466 * @param data The user data associated with the pool.
+00467 * @param key The key for the data to retrieve
+00468 * @param pool The current pool.
+00469 */
+00470 APR_DECLARE(apr_status_t) apr_pool_userdata_get(void **data, const char *key,
+00471 apr_pool_t *pool);
+00472
00473
00474 /**
-00475 * Get the parent pool of the specified pool.
-00476 * @param pool The pool for retrieving the parent pool.
-00477 * @return The parent of the given pool.
-00478 */
-00479 APR_DECLARE(apr_pool_t *) apr_pool_parent_get(apr_pool_t *pool);
-00480
-00481 /**
-00482 * Determine if pool a is an ancestor of pool b.
-00483 * @param a The pool to search
-00484 * @param b The pool to search for
-00485 * @return True if a is an ancestor of b, NULL is considered an ancestor
-00486 * of all pools.
-00487 * @remark if compiled with APR_POOL_DEBUG, this function will also
-00488 * return true if A is a pool which has been guaranteed by the caller
-00489 * (using apr_pool_join) to have a lifetime at least as long as some
-00490 * ancestor of pool B.
-00491 */
-00492 APR_DECLARE(int) apr_pool_is_ancestor(apr_pool_t *a, apr_pool_t *b);
-00493
-00494 /**
-00495 * Tag a pool (give it a name)
-00496 * @param pool The pool to tag
-00497 * @param tag The tag
-00498 */
-00499 APR_DECLARE(void) apr_pool_tag(apr_pool_t *pool, const char *tag);
-00500
-00501
-00502 /*
-00503 * User data management
-00504 */
-00505
-00506 /**
-00507 * Set the data associated with the current pool
-00508 * @param data The user data associated with the pool.
-00509 * @param key The key to use for association
-00510 * @param cleanup The cleanup program to use to cleanup the data (NULL if none)
-00511 * @param pool The current pool
-00512 * @warning The data to be attached to the pool should have a life span
-00513 * at least as long as the pool it is being attached to.
-00514 *
-00515 * Users of APR must take EXTREME care when choosing a key to
-00516 * use for their data. It is possible to accidentally overwrite
-00517 * data by choosing a key that another part of the program is using.
-00518 * Therefore it is advised that steps are taken to ensure that unique
-00519 * keys are used for all of the userdata objects in a particular pool
-00520 * (the same key in two different pools or a pool and one of its
-00521 * subpools is okay) at all times. Careful namespace prefixing of
-00522 * key names is a typical way to help ensure this uniqueness.
-00523 *
-00524 */
-00525 APR_DECLARE(apr_status_t) apr_pool_userdata_set(
-00526 const void *data,
-00527 const char *key,
-00528 apr_status_t (*cleanup)(void *),
-00529 apr_pool_t *pool);
-00530
-00531 /**
-00532 * Set the data associated with the current pool
-00533 * @param data The user data associated with the pool.
-00534 * @param key The key to use for association
-00535 * @param cleanup The cleanup program to use to cleanup the data (NULL if none)
-00536 * @param pool The current pool
-00537 * @note same as apr_pool_userdata_set(), except that this version doesn't
-00538 * make a copy of the key (this function is useful, for example, when
-00539 * the key is a string literal)
-00540 * @warning This should NOT be used if the key could change addresses by
-00541 * any means between the apr_pool_userdata_setn() call and a
-00542 * subsequent apr_pool_userdata_get() on that key, such as if a
-00543 * static string is used as a userdata key in a DSO and the DSO could
-00544 * be unloaded and reloaded between the _setn() and the _get(). You
-00545 * MUST use apr_pool_userdata_set() in such cases.
-00546 * @warning More generally, the key and the data to be attached to the
-00547 * pool should have a life span at least as long as the pool itself.
-00548 *
-00549 */
-00550 APR_DECLARE(apr_status_t) apr_pool_userdata_setn(
-00551 const void *data,
-00552 const char *key,
-00553 apr_status_t (*cleanup)(void *),
-00554 apr_pool_t *pool);
-00555
-00556 /**
-00557 * Return the data associated with the current pool.
-00558 * @param data The user data associated with the pool.
-00559 * @param key The key for the data to retrieve
-00560 * @param pool The current pool.
-00561 */
-00562 APR_DECLARE(apr_status_t) apr_pool_userdata_get(void **data, const char *key,
-00563 apr_pool_t *pool);
-00564
-00565
-00566 /**
-00567 * @defgroup PoolCleanup Pool Cleanup Functions
-00568 *
-00569 * Cleanups are performed in the reverse order they were registered. That is:
-00570 * Last In, First Out. A cleanup function can safely allocate memory from
-00571 * the pool that is being cleaned up. It can also safely register additional
-00572 * cleanups which will be run LIFO, directly after the current cleanup
-00573 * terminates. Cleanups have to take caution in calling functions that
-00574 * create subpools. Subpools, created during cleanup will NOT automatically
-00575 * be cleaned up. In other words, cleanups are to clean up after themselves.
-00576 *
-00577 * @{
-00578 */
-00579
-00580 /**
-00581 * Register a function to be called when a pool is cleared or destroyed
-00582 * @param p The pool register the cleanup with
-00583 * @param data The data to pass to the cleanup function.
-00584 * @param plain_cleanup The function to call when the pool is cleared
-00585 * or destroyed
-00586 * @param child_cleanup The function to call when a child process is about
-00587 * to exec - this function is called in the child, obviously!
-00588 */
-00589 APR_DECLARE(void) apr_pool_cleanup_register(
-00590 apr_pool_t *p,
-00591 const void *data,
-00592 apr_status_t (*plain_cleanup)(void *),
-00593 apr_status_t (*child_cleanup)(void *));
-00594
-00595 /**
-00596 * Register a function to be called when a pool is cleared or destroyed.
-00597 *
-00598 * Unlike apr_pool_cleanup_register which register a cleanup
-00599 * that is called AFTER all subpools are destroyed this function register
-00600 * a function that will be called before any of the subpool is destoryed.
-00601 *
-00602 * @param p The pool register the cleanup with
-00603 * @param data The data to pass to the cleanup function.
-00604 * @param plain_cleanup The function to call when the pool is cleared
-00605 * or destroyed
-00606 */
-00607 APR_DECLARE(void) apr_pool_pre_cleanup_register(
-00608 apr_pool_t *p,
-00609 const void *data,
-00610 apr_status_t (*plain_cleanup)(void *));
-00611
-00612 /**
-00613 * Remove a previously registered cleanup function.
-00614 *
-00615 * The cleanup most recently registered with @a p having the same values of
-00616 * @a data and @a cleanup will be removed.
-00617 *
-00618 * @param p The pool to remove the cleanup from
-00619 * @param data The data of the registered cleanup
-00620 * @param cleanup The function to remove from cleanup
-00621 * @remarks For some strange reason only the plain_cleanup is handled by this
-00622 * function
-00623 */
-00624 APR_DECLARE(void) apr_pool_cleanup_kill(apr_pool_t *p, const void *data,
-00625 apr_status_t (*cleanup)(void *));
-00626
-00627 /**
-00628 * Replace the child cleanup function of a previously registered cleanup.
-00629 *
-00630 * The cleanup most recently registered with @a p having the same values of
-00631 * @a data and @a plain_cleanup will have the registered child cleanup
-00632 * function replaced with @a child_cleanup.
-00633 *
-00634 * @param p The pool of the registered cleanup
-00635 * @param data The data of the registered cleanup
-00636 * @param plain_cleanup The plain cleanup function of the registered cleanup
-00637 * @param child_cleanup The function to register as the child cleanup
-00638 */
-00639 APR_DECLARE(void) apr_pool_child_cleanup_set(
-00640 apr_pool_t *p,
-00641 const void *data,
-00642 apr_status_t (*plain_cleanup)(void *),
-00643 apr_status_t (*child_cleanup)(void *));
+00475 * @defgroup PoolCleanup Pool Cleanup Functions
+00476 *
+00477 * Cleanups are performed in the reverse order they were registered. That is:
+00478 * Last In, First Out. A cleanup function can safely allocate memory from
+00479 * the pool that is being cleaned up. It can also safely register additional
+00480 * cleanups which will be run LIFO, directly after the current cleanup
+00481 * terminates. Cleanups have to take caution in calling functions that
+00482 * create subpools. Subpools, created during cleanup will NOT automatically
+00483 * be cleaned up. In other words, cleanups are to clean up after themselves.
+00484 *
+00485 * @{
+00486 */
+00487
+00488 /**
+00489 * Register a function to be called when a pool is cleared or destroyed
+00490 * @param p The pool register the cleanup with
[... 330 lines stripped ...]