[Top] | [Contents] | [Index] | [ ? ] |
Copyright (C) 2005 Don Owens
1. Data structures 2. Conf For reading configuration files 3. Options For parsing command-line arguments 4. Thread queue For queueing up requests for a separate thread 5. Timer An easy to use timer
License License under which libcfu is distributed
Concept index Function index
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
1.1 Hash table For key/value pairs 1.2 Linked list For unordered data 1.3 Strings For self-extending strings
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Creates a new hash table.
Creates a new hash table with the specified size (number of buckets).
Creates a new hash table with the specified flags. Pass zero for flags if you want the defaults.
Same as cfuhash_new() except automatically calls cfuhash_set_free_fn().
Copies entries in src to dst
Returns a new hash containing entries from both hash tables. For any entries with the same key, the one from ht2 wins.
Sets the hashing function to use when computing which bucket to add entries to. It should return a 32-bit unsigned integer. By default, Perl's hashing algorithm is used.
Sets the thresholds for when to rehash. The ratio num_entries/buckets is compared against low and high. If it is below 'low' or above 'high', the hash will shrink or grow, respectively, unless the flags say to do otherwise.
Sets the function to use when removing an entry from the hash, i.e., when replacing an existing entry, deleting an entry, or clearing the hash. It is passed the value of the entry as a void *.
Returns the hash's flags. See below for flag definitions.
Sets a flag.
Clears a flag.
Returns the value for the entry with given key. If key_size is -1, key is assumed to be a null-terminated string. If data_size is not NULL, the size of the value is placed into data_size.
Returns 1 if an entry with the given key exists in the hash, 0 otherwise.
Inserts the given data value into the hash and associates it with key. If key_size is -1, key is assumed to be a null-terminated string. If data_size is -1, it is assumed to be a null-terminated string (it's length will be calculated using strlen). If data_size is zero, it will be returned as zero when the value is requested.
Clears the hash table (deletes all entries).
Deletes the entry in the hash associated with key. If the entry existed, it's value will be returned.
Returns all the keys from the hash. The number of keys is placed into the value pointed to by num_keys. If key_sizes is not NULL, it will be set to an array of key sizes. If fast is zero, copies of the keys are returned. Otherwise, pointers to the real keys will be returned.
Initializes a loop over all the key/value pairs in the hash. It returns the first key/value pair (see cfuhash_next_data()). 1 is returned if there are any entries in the hash. 0 is returned otherwise.
Gets the next key/value pair from the hash. You must initialize the loop using cfuhash_each_data() before calling this function. If a entry is left to return, 1 is returned from the function. 0 is returned if there are no more entries in the hash.
Iterates over the key/value pairs in the hash, passing each one to r_fn, and removes all entries for which r_fn returns true. If ff is not NULL, it is the passed the data to be freed. arg is passed to r_fn.
Iterates over the key/value pairs in the hash, passing each one to fe_fn, along with arg. This locks the hash, so do not call any operations on the hash from within fe_fn unless you really know what you're doing.
If the return value from fe_fn() is not zero, the iteration stops.
Frees all resources allocated by the hash.
Frees all resources allocated by the hash. If ff is not NULL, it is called for each hash entry with the value of the entry passed as its only argument. If ff is not NULL, it overrides any function set previously with cfuhash_set_free_function().
Rebuild the hash to better accomodate the number of entries. See cfuhash_set_thresholds().
Returns the number entries in the hash.
Returns the number of buckets allocated for the hash.
Returns the number of buckets actually used out of the total number allocated for the hash.
Assumes all the keys and values are null-terminated strings and returns a bencoded string representing the hash (see http://www.bittorrent.com/protocol.html)
Locks the hash. Use this with the each and next functions for concurrency control. Note that the hash is locked automatically when doing inserts and deletes, so if you lock the hash and then try to insert something into it, you may get into a deadlock, depending on your system defaults for how mutexes work.
Unlocks the hash. Use this with the each an next functions for concurrency control. The caveat for cfuhash_lock() also applies to this function.
Pretty print the hash's key/value pairs to the stream fp. It is assumed that all the keys and values are null-terminated strings.
These are like the _data versions of these functions, with the following exceptions:
1) They assume that the key provided is a null-terminated string.
2) They don't worry about the size of the data.
3) Returned keys or values are the return value of the function.
Valid flags for cfuhash_new() or cfuhash_set_flag):
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Returns a new list.
Returns the number of entries in the list.
Push a value onto the end of the list.
Pop a value from the end of the list (removing it from the list).
Add a value at the beginning of the list.
Shift a value off the beginning of the list.
Add a value at the end of the queue (equivalent to push)
Remove the value at the beginning of the list (equivalent to shift).
Return the first entry from the list (without removing it from the list).
Return the last entry from the list (without removing it from the list).
Return the nth entry from the list (without removing it from the list). n starts at zero.
Calls fe_fn() for each element in the list. Also passes arg on each call. Do not try to manipulate the list inside fe_fn(), as the list will be locked.
If fe_fn() returns a non-zero value, the iteration over the elements stops.
Free all resources used by the list.
Free all resources used by the list. If free_fn is not NULL, call it for each element of the list, passing the data to it as a void *.
When you don't care about the size of the data
Strings -- assume data is a null-terminated string -- size is calculated by strlen(data) + 1
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Returns a new String.
Returns a new String initalized with the given string.
Overwrite anything currently in cfu_str with string.
Truncate the string.
Append str to the end of the buffer in cfu_str.
Get the buffer used to hold the string. Do not free() it, as it is used directly by cfustring and will be destroyed when cfustring_destroy() is called.
Same as cfustring_get_buffer(), except return a copy of the string. Caller is responsible for deallocating the buffer with free().
Split cfu_str on one or more delimiting strings, e.g., cfustring_split(cfu_str, 2, 0, "\r\n", "\n"). Use a limit > 0 if you want to only get back a certain number of strings and ignore any extra delimiters.
Same as cfustring_split(), except return an array of C-strings. Caller is responsible for deallocating the buffers.
Free all resources allocated by cfu_str.
Duplicate the C string str. Caller must free with free().
Same as cfustring_dup_c_str(), but only copy at most n chars
Like sprintf(), but writes to a self-extending string.
Similar to sprintf(), but allocates a C string of the appropriate size for you and returns it.
Like cfustring_split_to_c_str(), but split a char * instead of a cfustring_t *.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
This needs to be better documented.
Apache-style conf files contain directives and containers. Directives are simple one line specifications with or without arguments, e.g.,
Doit Expires On LoadModule my_mod modules/my_mod.so
Containers have a type and a name associated with them and they in turn contain directives and/or containers, e.g.,
<MyContainer test1> Expires Off <DB devdb> DBHost db.example.com DBUser test_user </DB> </MyContainer>
Values may be quoted, e.g.
DBUser "test user"
But must be specified on a single line. To escape quotes within a quoted string, use the '\' character.
Parse the apache-like conf file specified by file_path, returning a pointer to a cfuconf_t structure in conf. Returns zero on success, less than zero on error. If an error occurs and error is not NULL, it will be set to an error message (which must be free()'d by the caller).
Same as cfuconf_parse_file(), except assume the contents of the file are already in buffer.
Free all resources used by the cfuconf_t structure
Get a hash of containers at the top level of conf
Get a hash of directives at the to level
Get the value of the given directive, assuming there is only one argument
Get the value of the given directive, assuming there are two arguments
Get the value of the given directives, with n arguments
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Command-line arguments can be parsed with the following:
@verbatim cfuopt_t *opt = cfuopt_new(); cfuopt_add_entry(opt, "verbose|v!", &verbose, "Verbosity", ""); cfuopt_add_entry(opt, "file|f:s", &file, "File to load", "FILE"); cfuopt_add_entry(opt, "count|c|n=i", &count, "Count to run", "COUNT"); cfuopt_add_entry(opt, "scale|s:f", &scale, "Scaling factor", "SCALE"); cfuopt_parse(opt, &argc, &argv, &error); /* do stuff here with the options */ cfuopt_destroy(opt); free(file);
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
cfuthread_queue provides a way to serialize requests for a resource where you want the resource to be accessed from a single thread only. For instance, for a database connection where making calls in separate threads does not work properly, you can use cfuthread_queue. cfuthread_queue_new() creates a new thread that waits for something to be added to the queue. Once something is added, the thread will process the data by calling the function you pass as an argument to the cfuthread_queue_new() function.
Creates a new thread queue structure that will run the given function when a request is received.
Same as cfuthread_queue_new(), but with an initialization function that gets called with the argument init_arg when the thread is created, and a cleanup function that gets called with the argument cleanup_arg when the thread exits, e.g., when cfuthread_queue_destroy() is called.
Add a request to the queue. data will get passed to the function fn given to cfuthread_queue_new when it reaches the front of the queue.
Free up resources used by the queue, in addition to canceling the thread.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Return a new cfutime structure.
Start the timer.
Stop the timer.
Return the number of seconds elapsed as a double.
Deallocate resources allocated for time.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Copyright (C) 2005 Don Owens All rights reserved.
This code is released under the BSD license:
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
* Neither the name of the author nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Jump to: | A C D H L O Q S T |
---|
Jump to: | A C D H L O Q S T |
---|
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Jump to: | (
*
C T |
---|
Jump to: | (
*
C T |
---|
[Top] | [Contents] | [Index] | [ ? ] |
[Top] | [Contents] | [Index] | [ ? ] |
1. Data structures
2. Conf
3. Options
4. Thread queue
5. Timer
License
Concept index
Function index
[Top] | [Contents] | [Index] | [ ? ] |
Button | Name | Go to | From 1.2.3 go to |
---|---|---|---|
[ < ] | Back | previous section in reading order | 1.2.2 |
[ > ] | Forward | next section in reading order | 1.2.4 |
[ << ] | FastBack | previous or up-and-previous section | 1.1 |
[ Up ] | Up | up section | 1.2 |
[ >> ] | FastForward | next or up-and-next section | 1.3 |
[Top] | Top | cover (top) of document | |
[Contents] | Contents | table of contents | |
[Index] | Index | concept index | |
[ ? ] | About | this page |