home *** CD-ROM | disk | FTP | other *** search
/ Chip 2004 November / CMCD1104.ISO / Software / Complet / Apache / apache_2.0.52-win32-x86-no_ssl.msi / Data.Cab / F277235_apr_tables.h < prev    next >
C/C++ Source or Header  |  2004-02-13  |  16KB  |  422 lines
  1. /* Copyright 2000-2004 The Apache Software Foundation
  2.  *
  3.  * Licensed under the Apache License, Version 2.0 (the "License");
  4.  * you may not use this file except in compliance with the License.
  5.  * You may obtain a copy of the License at
  6.  *
  7.  *     http://www.apache.org/licenses/LICENSE-2.0
  8.  *
  9.  * Unless required by applicable law or agreed to in writing, software
  10.  * distributed under the License is distributed on an "AS IS" BASIS,
  11.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12.  * See the License for the specific language governing permissions and
  13.  * limitations under the License.
  14.  */
  15.  
  16. #ifndef APR_TABLES_H
  17. #define APR_TABLES_H
  18.  
  19. /**
  20.  * @file apr_tables.h
  21.  * @brief APR Table library
  22.  */
  23.  
  24. #include "apr.h"
  25. #include "apr_pools.h"
  26.  
  27. #if APR_HAVE_STDARG_H
  28. #include <stdarg.h>     /* for va_list */
  29. #endif
  30.  
  31. #ifdef __cplusplus
  32. extern "C" {
  33. #endif /* __cplusplus */
  34.  
  35. /**
  36.  * @defgroup apr_tables Table and Array Functions
  37.  * @ingroup APR 
  38.  * Tables are used to store entirely opaque structures 
  39.  * for applications, while Arrays are usually used to
  40.  * deal with string lists.
  41.  * @{
  42.  */
  43.  
  44. /** the table abstract data type */
  45. typedef struct apr_table_t apr_table_t;
  46.  
  47. /** @see apr_array_header_t */
  48. typedef struct apr_array_header_t apr_array_header_t;
  49.  
  50. /** An opaque array type */
  51. struct apr_array_header_t {
  52.     /** The pool the array is allocated out of */
  53.     apr_pool_t *pool;
  54.     /** The amount of memory allocated for each element of the array */
  55.     int elt_size;
  56.     /** The number of active elements in the array */
  57.     int nelts;
  58.     /** The number of elements allocated in the array */
  59.     int nalloc;
  60.     /** The elements in the array */
  61.     char *elts;
  62. };
  63.  
  64. /**
  65.  * The (opaque) structure for string-content tables.
  66.  */
  67. typedef struct apr_table_entry_t apr_table_entry_t;
  68.  
  69. /** The type for each entry in a string-content table */
  70. struct apr_table_entry_t {
  71.     /** The key for the current table entry */
  72.     char *key;          /* maybe NULL in future;
  73.                          * check when iterating thru table_elts
  74.                          */
  75.     /** The value for the current table entry */
  76.     char *val;
  77.  
  78.     /** A checksum for the key, for use by the apr_table internals */
  79.     apr_uint32_t key_checksum;
  80. };
  81.  
  82. /**
  83.  * Get the elements from a table
  84.  * @param t The table
  85.  * @return An array containing the contents of the table
  86.  */
  87. APR_DECLARE(const apr_array_header_t *) apr_table_elts(const apr_table_t *t);
  88.  
  89. /**
  90.  * Determine if the table is empty
  91.  * @param t The table to check
  92.  * @return True if empty, False otherwise
  93.  */
  94. APR_DECLARE(int) apr_is_empty_table(const apr_table_t *t);
  95.  
  96. /**
  97.  * Determine if the array is empty
  98.  * @param a The array to check
  99.  * @return True if empty, False otherwise
  100.  */
  101. APR_DECLARE(int) apr_is_empty_array(const apr_array_header_t *a);
  102.  
  103. /**
  104.  * Create an array
  105.  * @param p The pool to allocate the memory out of
  106.  * @param nelts the number of elements in the initial array
  107.  * @param elt_size The size of each element in the array.
  108.  * @return The new array
  109.  */
  110. APR_DECLARE(apr_array_header_t *) apr_array_make(apr_pool_t *p,
  111.                                                  int nelts, int elt_size);
  112.  
  113. /**
  114.  * Add a new element to an array
  115.  * @param arr The array to add an element to.
  116.  * @return Location for the new element in the array.
  117.  * @remark If there are no free spots in the array, then this function will
  118.  *         allocate new space for the new element.
  119.  */
  120. APR_DECLARE(void *) apr_array_push(apr_array_header_t *arr);
  121.  
  122. /**
  123.  * Remove an element from an array
  124.  * @param arr The array to remove an element from.
  125.  * @return Location of the element in the array.
  126.  * @remark If there are no elements in the array, NULL is returned.
  127.  */
  128. APR_DECLARE(void *) apr_array_pop(apr_array_header_t *arr);
  129.  
  130. /**
  131.  * Concatenate two arrays together
  132.  * @param dst The destination array, and the one to go first in the combined 
  133.  *            array
  134.  * @param src The source array to add to the destination array
  135.  */
  136. APR_DECLARE(void) apr_array_cat(apr_array_header_t *dst,
  137.                     const apr_array_header_t *src);
  138.  
  139. /**
  140.  * Copy the entire array
  141.  * @param p The pool to allocate the copy of the array out of
  142.  * @param arr The array to copy
  143.  * @return An exact copy of the array passed in
  144.  * @remark The alternate apr_array_copy_hdr copies only the header, and arranges 
  145.  *         for the elements to be copied if (and only if) the code subsequently
  146.  *         does a push or arraycat.
  147.  */
  148. APR_DECLARE(apr_array_header_t *) apr_array_copy(apr_pool_t *p,
  149.                                       const apr_array_header_t *arr);
  150. /**
  151.  * Copy the headers of the array, and arrange for the elements to be copied if
  152.  * and only if the code subsequently does a push or arraycat.
  153.  * @param p The pool to allocate the copy of the array out of
  154.  * @param arr The array to copy
  155.  * @return An exact copy of the array passed in
  156.  * @remark The alternate apr_array_copy copies the *entire* array.
  157.  */
  158. APR_DECLARE(apr_array_header_t *) apr_array_copy_hdr(apr_pool_t *p,
  159.                                       const apr_array_header_t *arr);
  160.  
  161. /**
  162.  * Append one array to the end of another, creating a new array in the process.
  163.  * @param p The pool to allocate the new array out of
  164.  * @param first The array to put first in the new array.
  165.  * @param second The array to put second in the new array.
  166.  * @return A new array containing the data from the two arrays passed in.
  167. */
  168. APR_DECLARE(apr_array_header_t *) apr_array_append(apr_pool_t *p,
  169.                                       const apr_array_header_t *first,
  170.                                       const apr_array_header_t *second);
  171.  
  172. /**
  173.  * Generates a new string from the apr_pool_t containing the concatenated 
  174.  * sequence of substrings referenced as elements within the array.  The string 
  175.  * will be empty if all substrings are empty or null, or if there are no 
  176.  * elements in the array.  If sep is non-NUL, it will be inserted between 
  177.  * elements as a separator.
  178.  * @param p The pool to allocate the string out of
  179.  * @param arr The array to generate the string from
  180.  * @param sep The separator to use
  181.  * @return A string containing all of the data in the array.
  182.  */
  183. APR_DECLARE(char *) apr_array_pstrcat(apr_pool_t *p,
  184.                       const apr_array_header_t *arr,
  185.                       const char sep);
  186.  
  187. /**
  188.  * Make a new table
  189.  * @param p The pool to allocate the pool out of
  190.  * @param nelts The number of elements in the initial table.
  191.  * @return The new table.
  192.  * @warning This table can only store text data
  193.  */
  194. APR_DECLARE(apr_table_t *) apr_table_make(apr_pool_t *p, int nelts);
  195.  
  196. /**
  197.  * Create a new table and copy another table into it
  198.  * @param p The pool to allocate the new table out of
  199.  * @param t The table to copy
  200.  * @return A copy of the table passed in
  201.  */
  202. APR_DECLARE(apr_table_t *) apr_table_copy(apr_pool_t *p,
  203.                                           const apr_table_t *t);
  204.  
  205. /**
  206.  * Delete all of the elements from a table
  207.  * @param t The table to clear
  208.  */
  209. APR_DECLARE(void) apr_table_clear(apr_table_t *t);
  210.  
  211. /**
  212.  * Get the value associated with a given key from the table.  After this call,
  213.  * The data is still in the table
  214.  * @param t The table to search for the key
  215.  * @param key The key to search for
  216.  * @return The value associated with the key
  217.  */
  218. APR_DECLARE(const char *) apr_table_get(const apr_table_t *t, const char *key);
  219.  
  220. /**
  221.  * Add a key/value pair to a table, if another element already exists with the
  222.  * same key, this will over-write the old data.
  223.  * @param t The table to add the data to.
  224.  * @param key The key fo use
  225.  * @param val The value to add
  226.  * @remark When adding data, this function makes a copy of both the key and the
  227.  *         value.
  228.  */
  229. APR_DECLARE(void) apr_table_set(apr_table_t *t, const char *key,
  230.                                 const char *val);
  231.  
  232. /**
  233.  * Add a key/value pair to a table, if another element already exists with the
  234.  * same key, this will over-write the old data.
  235.  * @param t The table to add the data to.
  236.  * @param key The key to use
  237.  * @param val The value to add
  238.  * @warning When adding data, this function does not make a copy of the key or 
  239.  *          the value, so care should be taken to ensure that the values will 
  240.  *          not change after they have been added..
  241.  */
  242. APR_DECLARE(void) apr_table_setn(apr_table_t *t, const char *key,
  243.                                  const char *val);
  244.  
  245. /**
  246.  * Remove data from the table
  247.  * @param t The table to remove data from
  248.  * @param key The key of the data being removed
  249.  */
  250. APR_DECLARE(void) apr_table_unset(apr_table_t *t, const char *key);
  251.  
  252. /**
  253.  * Add data to a table by merging the value with data that has already been 
  254.  * stored
  255.  * @param t The table to search for the data
  256.  * @param key The key to merge data for
  257.  * @param val The data to add
  258.  * @remark If the key is not found, then this function acts like apr_table_add
  259.  */
  260. APR_DECLARE(void) apr_table_merge(apr_table_t *t, const char *key,
  261.                                   const char *val);
  262.  
  263. /**
  264.  * Add data to a table by merging the value with data that has already been 
  265.  * stored
  266.  * @param t The table to search for the data
  267.  * @param key The key to merge data for
  268.  * @param val The data to add
  269.  * @remark If the key is not found, then this function acts like apr_table_addn
  270.  */
  271. APR_DECLARE(void) apr_table_mergen(apr_table_t *t, const char *key,
  272.                                    const char *val);
  273.  
  274. /**
  275.  * Add data to a table, regardless of whether there is another element with the
  276.  * same key.
  277.  * @param t The table to add to
  278.  * @param key The key to use
  279.  * @param val The value to add.
  280.  * @remark When adding data, this function makes a copy of both the key and the
  281.  *         value.
  282.  */
  283. APR_DECLARE(void) apr_table_add(apr_table_t *t, const char *key,
  284.                                 const char *val);
  285.  
  286. /**
  287.  * Add data to a table, regardless of whether there is another element with the
  288.  * same key.
  289.  * @param t The table to add to
  290.  * @param key The key to use
  291.  * @param val The value to add.
  292.  * @remark When adding data, this function does not make a copy of the key or the
  293.  *         value, so care should be taken to ensure that the values will not 
  294.  *         change after they have been added..
  295.  */
  296. APR_DECLARE(void) apr_table_addn(apr_table_t *t, const char *key,
  297.                                  const char *val);
  298.  
  299. /**
  300.  * Merge two tables into one new table
  301.  * @param p The pool to use for the new table
  302.  * @param overlay The first table to put in the new table
  303.  * @param base The table to add at the end of the new table
  304.  * @return A new table containing all of the data from the two passed in
  305.  */
  306. APR_DECLARE(apr_table_t *) apr_table_overlay(apr_pool_t *p,
  307.                                              const apr_table_t *overlay,
  308.                                              const apr_table_t *base);
  309.  
  310. /**
  311.  * Declaration prototype for the iterator callback function of apr_table_do()
  312.  * and apr_table_vdo().
  313.  * @param rec The data passed as the first argument to apr_table_[v]do()
  314.  * @param key The key from this iteration of the table
  315.  * @param value The value from this iteration of the table
  316.  * @remark Iteration continues while this callback function returns non-zero.
  317.  * To export the callback function for apr_table_[v]do() it must be declared 
  318.  * in the _NONSTD convention.
  319.  */
  320. typedef int (apr_table_do_callback_fn_t)(void *rec, const char *key, 
  321.                                                     const char *value);
  322.  
  323. /** 
  324.  * Iterate over a table running the provided function once for every
  325.  * element in the table.  If there is data passed in as a vararg, then the 
  326.  * function is only run on those elements whose key matches something in 
  327.  * the vararg.  If the vararg is NULL, then every element is run through the
  328.  * function.  Iteration continues while the function returns non-zero.
  329.  * @param comp The function to run
  330.  * @param rec The data to pass as the first argument to the function
  331.  * @param t The table to iterate over
  332.  * @param ... The vararg.  If this is NULL, then all elements in the table are
  333.  *            run through the function, otherwise only those whose key matches
  334.  *            are run.
  335.  * @return FALSE if one of the comp() iterations returned zero; TRUE if all
  336.  *            iterations returned non-zero
  337.  * @see apr_table_do_callback_fn_t
  338.  */
  339. APR_DECLARE_NONSTD(int) apr_table_do(apr_table_do_callback_fn_t *comp,
  340.                                      void *rec, const apr_table_t *t, ...);
  341.  
  342. /** 
  343.  * Iterate over a table running the provided function once for every
  344.  * element in the table.  If there is data passed in as a vararg, then the 
  345.  * function is only run on those element's whose key matches something in 
  346.  * the vararg.  If the vararg is NULL, then every element is run through the
  347.  * function.  Iteration continues while the function returns non-zero.
  348.  * @param comp The function to run
  349.  * @param rec The data to pass as the first argument to the function
  350.  * @param t The table to iterate over
  351.  * @param vp The vararg table.  If this is NULL, then all elements in the 
  352.  *                table are run through the function, otherwise only those 
  353.  *                whose key matches are run.
  354.  * @return FALSE if one of the comp() iterations returned zero; TRUE if all
  355.  *            iterations returned non-zero
  356.  * @see apr_table_do_callback_fn_t
  357.  */
  358. APR_DECLARE(int) apr_table_vdo(apr_table_do_callback_fn_t *comp,
  359.                                void *rec, const apr_table_t *t, va_list vp);
  360.  
  361. /** flag for overlap to use apr_table_setn */
  362. #define APR_OVERLAP_TABLES_SET   (0)
  363. /** flag for overlap to use apr_table_mergen */
  364. #define APR_OVERLAP_TABLES_MERGE (1)
  365. /**
  366.  * For each element in table b, either use setn or mergen to add the data
  367.  * to table a.  Which method is used is determined by the flags passed in.
  368.  * @param a The table to add the data to.
  369.  * @param b The table to iterate over, adding its data to table a
  370.  * @param flags How to add the table to table a.  One of:
  371.  *          APR_OVERLAP_TABLES_SET        Use apr_table_setn
  372.  *          APR_OVERLAP_TABLES_MERGE      Use apr_table_mergen
  373.  * @remark  This function is highly optimized, and uses less memory and CPU cycles
  374.  *          than a function that just loops through table b calling other functions.
  375.  */
  376. /**
  377.  *<PRE>
  378.  * Conceptually, apr_table_overlap does this:
  379.  *
  380.  *  apr_array_header_t *barr = apr_table_elts(b);
  381.  *  apr_table_entry_t *belt = (apr_table_entry_t *)barr->elts;
  382.  *  int i;
  383.  *
  384.  *  for (i = 0; i < barr->nelts; ++i) {
  385.  *      if (flags & APR_OVERLAP_TABLES_MERGE) {
  386.  *          apr_table_mergen(a, belt[i].key, belt[i].val);
  387.  *      }
  388.  *      else {
  389.  *          apr_table_setn(a, belt[i].key, belt[i].val);
  390.  *      }
  391.  *  }
  392.  *
  393.  *  Except that it is more efficient (less space and cpu-time) especially
  394.  *  when b has many elements.
  395.  *
  396.  *  Notice the assumptions on the keys and values in b -- they must be
  397.  *  in an ancestor of a's pool.  In practice b and a are usually from
  398.  *  the same pool.
  399.  * </PRE>
  400.  */
  401.  
  402. APR_DECLARE(void) apr_table_overlap(apr_table_t *a, const apr_table_t *b,
  403.                                      unsigned flags);
  404.  
  405. /**
  406.  * Eliminate redunandant entries in a table by either overwriting
  407.  * or merging duplicates
  408.  *
  409.  * @param t Table.
  410.  * @param flags APR_OVERLAP_TABLES_MERGE to merge, or
  411.  *              APR_OVERLAP_TABLES_SET to overwrite
  412.  */
  413. APR_DECLARE(void) apr_table_compress(apr_table_t *t, unsigned flags);
  414.  
  415. /** @} */
  416.  
  417. #ifdef __cplusplus
  418. }
  419. #endif
  420.  
  421. #endif    /* ! APR_TABLES_H */
  422.