summaryrefslogtreecommitdiffstats
path: root/rubbos/app/httpd-2.0.64/srclib/apr/include/apr_tables.h
diff options
context:
space:
mode:
authorhongbotian <hongbo.tianhongbo@huawei.com>2015-11-30 01:45:08 -0500
committerhongbotian <hongbo.tianhongbo@huawei.com>2015-11-30 01:45:08 -0500
commite8ec7aa8e38a93f5b034ac74cebce5de23710317 (patch)
treeaa031937bf856c1f8d6ad7877b8d2cb0224da5ef /rubbos/app/httpd-2.0.64/srclib/apr/include/apr_tables.h
parentcc40af334e619bb549038238507407866f774f8f (diff)
upload http
JIRA: BOTTLENECK-10 Change-Id: I7598427ff904df438ce77c2819ee48ac75ffa8da Signed-off-by: hongbotian <hongbo.tianhongbo@huawei.com>
Diffstat (limited to 'rubbos/app/httpd-2.0.64/srclib/apr/include/apr_tables.h')
-rw-r--r--rubbos/app/httpd-2.0.64/srclib/apr/include/apr_tables.h422
1 files changed, 422 insertions, 0 deletions
diff --git a/rubbos/app/httpd-2.0.64/srclib/apr/include/apr_tables.h b/rubbos/app/httpd-2.0.64/srclib/apr/include/apr_tables.h
new file mode 100644
index 00000000..f286b5c7
--- /dev/null
+++ b/rubbos/app/httpd-2.0.64/srclib/apr/include/apr_tables.h
@@ -0,0 +1,422 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef APR_TABLES_H
+#define APR_TABLES_H
+
+/**
+ * @file apr_tables.h
+ * @brief APR Table library
+ */
+
+#include "apr.h"
+#include "apr_pools.h"
+
+#if APR_HAVE_STDARG_H
+#include <stdarg.h> /* for va_list */
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/**
+ * @defgroup apr_tables Table and Array Functions
+ * @ingroup APR
+ * Tables are used to store entirely opaque structures
+ * for applications, while Arrays are usually used to
+ * deal with string lists.
+ * @{
+ */
+
+/** the table abstract data type */
+typedef struct apr_table_t apr_table_t;
+
+/** @see apr_array_header_t */
+typedef struct apr_array_header_t apr_array_header_t;
+
+/** An opaque array type */
+struct apr_array_header_t {
+ /** The pool the array is allocated out of */
+ apr_pool_t *pool;
+ /** The amount of memory allocated for each element of the array */
+ int elt_size;
+ /** The number of active elements in the array */
+ int nelts;
+ /** The number of elements allocated in the array */
+ int nalloc;
+ /** The elements in the array */
+ char *elts;
+};
+
+/**
+ * The (opaque) structure for string-content tables.
+ */
+typedef struct apr_table_entry_t apr_table_entry_t;
+
+/** The type for each entry in a string-content table */
+struct apr_table_entry_t {
+ /** The key for the current table entry */
+ char *key; /* maybe NULL in future;
+ * check when iterating thru table_elts
+ */
+ /** The value for the current table entry */
+ char *val;
+
+ /** A checksum for the key, for use by the apr_table internals */
+ apr_uint32_t key_checksum;
+};
+
+/**
+ * Get the elements from a table
+ * @param t The table
+ * @return An array containing the contents of the table
+ */
+APR_DECLARE(const apr_array_header_t *) apr_table_elts(const apr_table_t *t);
+
+/**
+ * Determine if the table is empty
+ * @param t The table to check
+ * @return True if empty, False otherwise
+ */
+APR_DECLARE(int) apr_is_empty_table(const apr_table_t *t);
+
+/**
+ * Determine if the array is empty
+ * @param a The array to check
+ * @return True if empty, False otherwise
+ */
+APR_DECLARE(int) apr_is_empty_array(const apr_array_header_t *a);
+
+/**
+ * Create an array
+ * @param p The pool to allocate the memory out of
+ * @param nelts the number of elements in the initial array
+ * @param elt_size The size of each element in the array.
+ * @return The new array
+ */
+APR_DECLARE(apr_array_header_t *) apr_array_make(apr_pool_t *p,
+ int nelts, int elt_size);
+
+/**
+ * Add a new element to an array
+ * @param arr The array to add an element to.
+ * @return Location for the new element in the array.
+ * @remark If there are no free spots in the array, then this function will
+ * allocate new space for the new element.
+ */
+APR_DECLARE(void *) apr_array_push(apr_array_header_t *arr);
+
+/**
+ * Remove an element from an array
+ * @param arr The array to remove an element from.
+ * @return Location of the element in the array.
+ * @remark If there are no elements in the array, NULL is returned.
+ */
+APR_DECLARE(void *) apr_array_pop(apr_array_header_t *arr);
+
+/**
+ * Concatenate two arrays together
+ * @param dst The destination array, and the one to go first in the combined
+ * array
+ * @param src The source array to add to the destination array
+ */
+APR_DECLARE(void) apr_array_cat(apr_array_header_t *dst,
+ const apr_array_header_t *src);
+
+/**
+ * Copy the entire array
+ * @param p The pool to allocate the copy of the array out of
+ * @param arr The array to copy
+ * @return An exact copy of the array passed in
+ * @remark The alternate apr_array_copy_hdr copies only the header, and arranges
+ * for the elements to be copied if (and only if) the code subsequently
+ * does a push or arraycat.
+ */
+APR_DECLARE(apr_array_header_t *) apr_array_copy(apr_pool_t *p,
+ const apr_array_header_t *arr);
+/**
+ * Copy the headers of the array, and arrange for the elements to be copied if
+ * and only if the code subsequently does a push or arraycat.
+ * @param p The pool to allocate the copy of the array out of
+ * @param arr The array to copy
+ * @return An exact copy of the array passed in
+ * @remark The alternate apr_array_copy copies the *entire* array.
+ */
+APR_DECLARE(apr_array_header_t *) apr_array_copy_hdr(apr_pool_t *p,
+ const apr_array_header_t *arr);
+
+/**
+ * Append one array to the end of another, creating a new array in the process.
+ * @param p The pool to allocate the new array out of
+ * @param first The array to put first in the new array.
+ * @param second The array to put second in the new array.
+ * @return A new array containing the data from the two arrays passed in.
+*/
+APR_DECLARE(apr_array_header_t *) apr_array_append(apr_pool_t *p,
+ const apr_array_header_t *first,
+ const apr_array_header_t *second);
+
+/**
+ * Generates a new string from the apr_pool_t containing the concatenated
+ * sequence of substrings referenced as elements within the array. The string
+ * will be empty if all substrings are empty or null, or if there are no
+ * elements in the array. If sep is non-NUL, it will be inserted between
+ * elements as a separator.
+ * @param p The pool to allocate the string out of
+ * @param arr The array to generate the string from
+ * @param sep The separator to use
+ * @return A string containing all of the data in the array.
+ */
+APR_DECLARE(char *) apr_array_pstrcat(apr_pool_t *p,
+ const apr_array_header_t *arr,
+ const char sep);
+
+/**
+ * Make a new table
+ * @param p The pool to allocate the pool out of
+ * @param nelts The number of elements in the initial table.
+ * @return The new table.
+ * @warning This table can only store text data
+ */
+APR_DECLARE(apr_table_t *) apr_table_make(apr_pool_t *p, int nelts);
+
+/**
+ * Create a new table and copy another table into it
+ * @param p The pool to allocate the new table out of
+ * @param t The table to copy
+ * @return A copy of the table passed in
+ */
+APR_DECLARE(apr_table_t *) apr_table_copy(apr_pool_t *p,
+ const apr_table_t *t);
+
+/**
+ * Delete all of the elements from a table
+ * @param t The table to clear
+ */
+APR_DECLARE(void) apr_table_clear(apr_table_t *t);
+
+/**
+ * Get the value associated with a given key from the table. After this call,
+ * The data is still in the table
+ * @param t The table to search for the key
+ * @param key The key to search for
+ * @return The value associated with the key
+ */
+APR_DECLARE(const char *) apr_table_get(const apr_table_t *t, const char *key);
+
+/**
+ * Add a key/value pair to a table, if another element already exists with the
+ * same key, this will over-write the old data.
+ * @param t The table to add the data to.
+ * @param key The key fo use
+ * @param val The value to add
+ * @remark When adding data, this function makes a copy of both the key and the
+ * value.
+ */
+APR_DECLARE(void) apr_table_set(apr_table_t *t, const char *key,
+ const char *val);
+
+/**
+ * Add a key/value pair to a table, if another element already exists with the
+ * same key, this will over-write the old data.
+ * @param t The table to add the data to.
+ * @param key The key to use
+ * @param val The value to add
+ * @warning When adding data, this function does not make a copy of the key or
+ * the value, so care should be taken to ensure that the values will
+ * not change after they have been added..
+ */
+APR_DECLARE(void) apr_table_setn(apr_table_t *t, const char *key,
+ const char *val);
+
+/**
+ * Remove data from the table
+ * @param t The table to remove data from
+ * @param key The key of the data being removed
+ */
+APR_DECLARE(void) apr_table_unset(apr_table_t *t, const char *key);
+
+/**
+ * Add data to a table by merging the value with data that has already been
+ * stored
+ * @param t The table to search for the data
+ * @param key The key to merge data for
+ * @param val The data to add
+ * @remark If the key is not found, then this function acts like apr_table_add
+ */
+APR_DECLARE(void) apr_table_merge(apr_table_t *t, const char *key,
+ const char *val);
+
+/**
+ * Add data to a table by merging the value with data that has already been
+ * stored
+ * @param t The table to search for the data
+ * @param key The key to merge data for
+ * @param val The data to add
+ * @remark If the key is not found, then this function acts like apr_table_addn
+ */
+APR_DECLARE(void) apr_table_mergen(apr_table_t *t, const char *key,
+ const char *val);
+
+/**
+ * Add data to a table, regardless of whether there is another element with the
+ * same key.
+ * @param t The table to add to
+ * @param key The key to use
+ * @param val The value to add.
+ * @remark When adding data, this function makes a copy of both the key and the
+ * value.
+ */
+APR_DECLARE(void) apr_table_add(apr_table_t *t, const char *key,
+ const char *val);
+
+/**
+ * Add data to a table, regardless of whether there is another element with the
+ * same key.
+ * @param t The table to add to
+ * @param key The key to use
+ * @param val The value to add.
+ * @remark When adding data, this function does not make a copy of the key or the
+ * value, so care should be taken to ensure that the values will not
+ * change after they have been added..
+ */
+APR_DECLARE(void) apr_table_addn(apr_table_t *t, const char *key,
+ const char *val);
+
+/**
+ * Merge two tables into one new table
+ * @param p The pool to use for the new table
+ * @param overlay The first table to put in the new table
+ * @param base The table to add at the end of the new table
+ * @return A new table containing all of the data from the two passed in
+ */
+APR_DECLARE(apr_table_t *) apr_table_overlay(apr_pool_t *p,
+ const apr_table_t *overlay,
+ const apr_table_t *base);
+
+/**
+ * Declaration prototype for the iterator callback function of apr_table_do()
+ * and apr_table_vdo().
+ * @param rec The data passed as the first argument to apr_table_[v]do()
+ * @param key The key from this iteration of the table
+ * @param value The value from this iteration of the table
+ * @remark Iteration continues while this callback function returns non-zero.
+ * To export the callback function for apr_table_[v]do() it must be declared
+ * in the _NONSTD convention.
+ */
+typedef int (apr_table_do_callback_fn_t)(void *rec, const char *key,
+ const char *value);
+
+/**
+ * Iterate over a table running the provided function once for every
+ * element in the table. If there is data passed in as a vararg, then the
+ * function is only run on those elements whose key matches something in
+ * the vararg. If the vararg is NULL, then every element is run through the
+ * function. Iteration continues while the function returns non-zero.
+ * @param comp The function to run
+ * @param rec The data to pass as the first argument to the function
+ * @param t The table to iterate over
+ * @param ... The vararg. If this is NULL, then all elements in the table are
+ * run through the function, otherwise only those whose key matches
+ * are run.
+ * @return FALSE if one of the comp() iterations returned zero; TRUE if all
+ * iterations returned non-zero
+ * @see apr_table_do_callback_fn_t
+ */
+APR_DECLARE_NONSTD(int) apr_table_do(apr_table_do_callback_fn_t *comp,
+ void *rec, const apr_table_t *t, ...);
+
+/**
+ * Iterate over a table running the provided function once for every
+ * element in the table. If there is data passed in as a vararg, then the
+ * function is only run on those element's whose key matches something in
+ * the vararg. If the vararg is NULL, then every element is run through the
+ * function. Iteration continues while the function returns non-zero.
+ * @param comp The function to run
+ * @param rec The data to pass as the first argument to the function
+ * @param t The table to iterate over
+ * @param vp The vararg table. If this is NULL, then all elements in the
+ * table are run through the function, otherwise only those
+ * whose key matches are run.
+ * @return FALSE if one of the comp() iterations returned zero; TRUE if all
+ * iterations returned non-zero
+ * @see apr_table_do_callback_fn_t
+ */
+APR_DECLARE(int) apr_table_vdo(apr_table_do_callback_fn_t *comp,
+ void *rec, const apr_table_t *t, va_list vp);
+
+/** flag for overlap to use apr_table_setn */
+#define APR_OVERLAP_TABLES_SET (0)
+/** flag for overlap to use apr_table_mergen */
+#define APR_OVERLAP_TABLES_MERGE (1)
+/**
+ * For each element in table b, either use setn or mergen to add the data
+ * to table a. Which method is used is determined by the flags passed in.
+ * @param a The table to add the data to.
+ * @param b The table to iterate over, adding its data to table a
+ * @param flags How to add the table to table a. One of:
+ * APR_OVERLAP_TABLES_SET Use apr_table_setn
+ * APR_OVERLAP_TABLES_MERGE Use apr_table_mergen
+ * @remark This function is highly optimized, and uses less memory and CPU cycles
+ * than a function that just loops through table b calling other functions.
+ */
+/**
+ *<PRE>
+ * Conceptually, apr_table_overlap does this:
+ *
+ * apr_array_header_t *barr = apr_table_elts(b);
+ * apr_table_entry_t *belt = (apr_table_entry_t *)barr->elts;
+ * int i;
+ *
+ * for (i = 0; i < barr->nelts; ++i) {
+ * if (flags & APR_OVERLAP_TABLES_MERGE) {
+ * apr_table_mergen(a, belt[i].key, belt[i].val);
+ * }
+ * else {
+ * apr_table_setn(a, belt[i].key, belt[i].val);
+ * }
+ * }
+ *
+ * Except that it is more efficient (less space and cpu-time) especially
+ * when b has many elements.
+ *
+ * Notice the assumptions on the keys and values in b -- they must be
+ * in an ancestor of a's pool. In practice b and a are usually from
+ * the same pool.
+ * </PRE>
+ */
+
+APR_DECLARE(void) apr_table_overlap(apr_table_t *a, const apr_table_t *b,
+ unsigned flags);
+
+/**
+ * Eliminate redunandant entries in a table by either overwriting
+ * or merging duplicates
+ *
+ * @param t Table.
+ * @param flags APR_OVERLAP_TABLES_MERGE to merge, or
+ * APR_OVERLAP_TABLES_SET to overwrite
+ */
+APR_DECLARE(void) apr_table_compress(apr_table_t *t, unsigned flags);
+
+/** @} */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ! APR_TABLES_H */