683 lines
21 KiB
C
683 lines
21 KiB
C
/*
|
|
* $Id$
|
|
*
|
|
Copyright (c) 2006-2020 Chung, Hyung-Hwan. All rights reserved.
|
|
|
|
Redistribution and use in source and binary forms, with or without
|
|
modification, are permitted provided that the following conditions
|
|
are met:
|
|
1. Redistributions of source code must retain the above copyright
|
|
notice, this list of conditions and the following disclaimer.
|
|
2. 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.
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE AUTHOR "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 AUTHOR 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.
|
|
*/
|
|
|
|
#ifndef _MIO_HTB_H_
|
|
#define _MIO_HTB_H_
|
|
|
|
#include <mio.h>
|
|
|
|
/**@file
|
|
* This file provides a hash table encapsulated in the #mio_htb_t type that
|
|
* maintains buckets for key/value pairs with the same key hash chained under
|
|
* the same bucket. Its interface is very close to #mio_rbt_t.
|
|
*
|
|
* This sample code adds a series of keys and values and print them
|
|
* in the randome order.
|
|
* @code
|
|
* #include <mio-htb.h>
|
|
*
|
|
* static mio_htb_walk_t walk (mio_htb_t* htb, mio_htb_pair_t* pair, void* ctx)
|
|
* {
|
|
* mio_printf (MIO_T("key = %d, value = %d\n"),
|
|
* *(int*)MIO_HTB_KPTR(pair), *(int*)MIO_HTB_VPTR(pair));
|
|
* return MIO_HTB_WALK_FORWARD;
|
|
* }
|
|
*
|
|
* int main ()
|
|
* {
|
|
* mio_htb_t* s1;
|
|
* int i;
|
|
*
|
|
* mio_open_stdsios ();
|
|
* s1 = mio_htb_open (MIO_MMGR_GETDFL(), 0, 30, 75, 1, 1); // error handling skipped
|
|
* mio_htb_setstyle (s1, mio_get_htb_style(MIO_HTB_STYLE_INLINE_COPIERS));
|
|
*
|
|
* for (i = 0; i < 20; i++)
|
|
* {
|
|
* int x = i * 20;
|
|
* mio_htb_insert (s1, &i, MIO_SIZEOF(i), &x, MIO_SIZEOF(x)); // eror handling skipped
|
|
* }
|
|
*
|
|
* mio_htb_walk (s1, walk, MIO_NULL);
|
|
*
|
|
* mio_htb_close (s1);
|
|
* mio_close_stdsios ();
|
|
* return 0;
|
|
* }
|
|
* @endcode
|
|
*/
|
|
|
|
typedef struct mio_htb_t mio_htb_t;
|
|
typedef struct mio_htb_pair_t mio_htb_pair_t;
|
|
|
|
/**
|
|
* The mio_htb_walk_t type defines values that the callback function can
|
|
* return to control mio_htb_walk().
|
|
*/
|
|
enum mio_htb_walk_t
|
|
{
|
|
MIO_HTB_WALK_STOP = 0,
|
|
MIO_HTB_WALK_FORWARD = 1
|
|
};
|
|
typedef enum mio_htb_walk_t mio_htb_walk_t;
|
|
|
|
/**
|
|
* The mio_htb_id_t type defines IDs to indicate a key or a value in various
|
|
* functions.
|
|
*/
|
|
enum mio_htb_id_t
|
|
{
|
|
MIO_HTB_KEY = 0,
|
|
MIO_HTB_VAL = 1
|
|
};
|
|
typedef enum mio_htb_id_t mio_htb_id_t;
|
|
|
|
/**
|
|
* The mio_htb_copier_t type defines a pair contruction callback.
|
|
* A special copier #MIO_HTB_COPIER_INLINE is provided. This copier enables
|
|
* you to copy the data inline to the internal node. No freeer is invoked
|
|
* when the node is freeed.
|
|
*/
|
|
typedef void* (*mio_htb_copier_t) (
|
|
mio_htb_t* htb /* hash table */,
|
|
void* dptr /* pointer to a key or a value */,
|
|
mio_oow_t dlen /* length of a key or a value */
|
|
);
|
|
|
|
/**
|
|
* The mio_htb_freeer_t defines a key/value destruction callback
|
|
* The freeer is called when a node containing the element is destroyed.
|
|
*/
|
|
typedef void (*mio_htb_freeer_t) (
|
|
mio_htb_t* htb, /**< hash table */
|
|
void* dptr, /**< pointer to a key or a value */
|
|
mio_oow_t dlen /**< length of a key or a value */
|
|
);
|
|
|
|
|
|
/**
|
|
* The mio_htb_comper_t type defines a key comparator that is called when
|
|
* the htb needs to compare keys. A hash table is created with a default
|
|
* comparator which performs bitwise comparison of two keys.
|
|
* The comparator should return 0 if the keys are the same and a non-zero
|
|
* integer otherwise.
|
|
*/
|
|
typedef int (*mio_htb_comper_t) (
|
|
const mio_htb_t* htb, /**< hash table */
|
|
const void* kptr1, /**< key pointer */
|
|
mio_oow_t klen1, /**< key length */
|
|
const void* kptr2, /**< key pointer */
|
|
mio_oow_t klen2 /**< key length */
|
|
);
|
|
|
|
/**
|
|
* The mio_htb_keeper_t type defines a value keeper that is called when
|
|
* a value is retained in the context that it should be destroyed because
|
|
* it is identical to a new value. Two values are identical if their
|
|
* pointers and lengths are equal.
|
|
*/
|
|
typedef void (*mio_htb_keeper_t) (
|
|
mio_htb_t* htb, /**< hash table */
|
|
void* vptr, /**< value pointer */
|
|
mio_oow_t vlen /**< value length */
|
|
);
|
|
|
|
/**
|
|
* The mio_htb_sizer_t type defines a bucket size claculator that is called
|
|
* when hash table should resize the bucket. The current bucket size + 1 is
|
|
* passed as the hint.
|
|
*/
|
|
typedef mio_oow_t (*mio_htb_sizer_t) (
|
|
mio_htb_t* htb, /**< htb */
|
|
mio_oow_t hint /**< sizing hint */
|
|
);
|
|
|
|
/**
|
|
* The mio_htb_hasher_t type defines a key hash function
|
|
*/
|
|
typedef mio_oow_t (*mio_htb_hasher_t) (
|
|
const mio_htb_t* htb, /**< hash table */
|
|
const void* kptr, /**< key pointer */
|
|
mio_oow_t klen /**< key length in bytes */
|
|
);
|
|
|
|
/**
|
|
* The mio_htb_walker_t defines a pair visitor.
|
|
*/
|
|
typedef mio_htb_walk_t (*mio_htb_walker_t) (
|
|
mio_htb_t* htb, /**< htb */
|
|
mio_htb_pair_t* pair, /**< pointer to a key/value pair */
|
|
void* ctx /**< pointer to user-defined data */
|
|
);
|
|
|
|
/**
|
|
* The mio_htb_cbserter_t type defines a callback function for mio_htb_cbsert().
|
|
* The mio_htb_cbserter() function calls it to allocate a new pair for the
|
|
* key pointed to by @a kptr of the length @a klen and the callback context
|
|
* @a ctx. The second parameter @a pair is passed the pointer to the existing
|
|
* pair for the key or #MIO_NULL in case of no existing key. The callback
|
|
* must return a pointer to a new or a reallocated pair. When reallocating the
|
|
* existing pair, this callback must destroy the existing pair and return the
|
|
* newly reallocated pair. It must return #MIO_NULL for failure.
|
|
*/
|
|
typedef mio_htb_pair_t* (*mio_htb_cbserter_t) (
|
|
mio_htb_t* htb, /**< hash table */
|
|
mio_htb_pair_t* pair, /**< pair pointer */
|
|
void* kptr, /**< key pointer */
|
|
mio_oow_t klen, /**< key length */
|
|
void* ctx /**< callback context */
|
|
);
|
|
|
|
|
|
/**
|
|
* The mio_htb_pair_t type defines hash table pair. A pair is composed of a key
|
|
* and a value. It maintains pointers to the beginning of a key and a value
|
|
* plus their length. The length is scaled down with the scale factor
|
|
* specified in an owning hash table.
|
|
*/
|
|
struct mio_htb_pair_t
|
|
{
|
|
mio_ptl_t key;
|
|
mio_ptl_t val;
|
|
|
|
/* management information below */
|
|
mio_htb_pair_t* next;
|
|
};
|
|
|
|
typedef struct mio_htb_style_t mio_htb_style_t;
|
|
|
|
struct mio_htb_style_t
|
|
{
|
|
mio_htb_copier_t copier[2];
|
|
mio_htb_freeer_t freeer[2];
|
|
mio_htb_comper_t comper; /**< key comparator */
|
|
mio_htb_keeper_t keeper; /**< value keeper */
|
|
mio_htb_sizer_t sizer; /**< bucket capacity recalculator */
|
|
mio_htb_hasher_t hasher; /**< key hasher */
|
|
};
|
|
|
|
/**
|
|
* The mio_htb_style_kind_t type defines the type of predefined
|
|
* callback set for pair manipulation.
|
|
*/
|
|
enum mio_htb_style_kind_t
|
|
{
|
|
/** store the key and the value pointer */
|
|
MIO_HTB_STYLE_DEFAULT,
|
|
/** copy both key and value into the pair */
|
|
MIO_HTB_STYLE_INLINE_COPIERS,
|
|
/** copy the key into the pair but store the value pointer */
|
|
MIO_HTB_STYLE_INLINE_KEY_COPIER,
|
|
/** copy the value into the pair but store the key pointer */
|
|
MIO_HTB_STYLE_INLINE_VALUE_COPIER
|
|
};
|
|
|
|
typedef enum mio_htb_style_kind_t mio_htb_style_kind_t;
|
|
|
|
/**
|
|
* The mio_htb_t type defines a hash table.
|
|
*/
|
|
struct mio_htb_t
|
|
{
|
|
mio_t* mio;
|
|
|
|
const mio_htb_style_t* style;
|
|
|
|
mio_uint8_t scale[2]; /**< length scale */
|
|
mio_uint8_t factor; /**< load factor in percentage */
|
|
|
|
mio_oow_t size;
|
|
mio_oow_t capa;
|
|
mio_oow_t threshold;
|
|
|
|
mio_htb_pair_t** bucket;
|
|
};
|
|
|
|
struct mio_htb_itr_t
|
|
{
|
|
mio_htb_pair_t* pair;
|
|
mio_oow_t buckno;
|
|
};
|
|
|
|
typedef struct mio_htb_itr_t mio_htb_itr_t;
|
|
|
|
/**
|
|
* The MIO_HTB_COPIER_SIMPLE macros defines a copier that remembers the
|
|
* pointer and length of data in a pair.
|
|
**/
|
|
#define MIO_HTB_COPIER_SIMPLE ((mio_htb_copier_t)1)
|
|
|
|
/**
|
|
* The MIO_HTB_COPIER_INLINE macros defines a copier that copies data into
|
|
* a pair.
|
|
**/
|
|
#define MIO_HTB_COPIER_INLINE ((mio_htb_copier_t)2)
|
|
|
|
#define MIO_HTB_COPIER_DEFAULT (MIO_HTB_COPIER_SIMPLE)
|
|
#define MIO_HTB_FREEER_DEFAULT (MIO_NULL)
|
|
#define MIO_HTB_COMPER_DEFAULT (mio_htb_dflcomp)
|
|
#define MIO_HTB_KEEPER_DEFAULT (MIO_NULL)
|
|
#define MIO_HTB_SIZER_DEFAULT (MIO_NULL)
|
|
#define MIO_HTB_HASHER_DEFAULT (mio_htb_dflhash)
|
|
|
|
/**
|
|
* The MIO_HTB_SIZE() macro returns the number of pairs in a hash table.
|
|
*/
|
|
#define MIO_HTB_SIZE(m) (*(const mio_oow_t*)&(m)->size)
|
|
|
|
/**
|
|
* The MIO_HTB_CAPA() macro returns the maximum number of pairs that can be
|
|
* stored in a hash table without further reorganization.
|
|
*/
|
|
#define MIO_HTB_CAPA(m) (*(const mio_oow_t*)&(m)->capa)
|
|
|
|
#define MIO_HTB_FACTOR(m) (*(const int*)&(m)->factor)
|
|
#define MIO_HTB_KSCALE(m) (*(const int*)&(m)->scale[MIO_HTB_KEY])
|
|
#define MIO_HTB_VSCALE(m) (*(const int*)&(m)->scale[MIO_HTB_VAL])
|
|
|
|
#define MIO_HTB_KPTL(p) (&(p)->key)
|
|
#define MIO_HTB_VPTL(p) (&(p)->val)
|
|
|
|
#define MIO_HTB_KPTR(p) ((p)->key.ptr)
|
|
#define MIO_HTB_KLEN(p) ((p)->key.len)
|
|
#define MIO_HTB_VPTR(p) ((p)->val.ptr)
|
|
#define MIO_HTB_VLEN(p) ((p)->val.len)
|
|
|
|
#define MIO_HTB_NEXT(p) ((p)->next)
|
|
|
|
#if defined(__cplusplus)
|
|
extern "C" {
|
|
#endif
|
|
|
|
/**
|
|
* The mio_get_htb_style() functions returns a predefined callback set for
|
|
* pair manipulation.
|
|
*/
|
|
MIO_EXPORT const mio_htb_style_t* mio_get_htb_style (
|
|
mio_htb_style_kind_t kind
|
|
);
|
|
|
|
/**
|
|
* The mio_htb_open() function creates a hash table with a dynamic array
|
|
* bucket and a list of values chained. The initial capacity should be larger
|
|
* than 0. The load factor should be between 0 and 100 inclusive and the load
|
|
* factor of 0 disables bucket resizing. If you need extra space associated
|
|
* with hash table, you may pass a non-zero value for @a xtnsize.
|
|
* The MIO_HTB_XTN() macro and the mio_htb_getxtn() function return the
|
|
* pointer to the beginning of the extension.
|
|
* The @a kscale and @a vscale parameters specify the unit of the key and
|
|
* value size.
|
|
* @return #mio_htb_t pointer on success, #MIO_NULL on failure.
|
|
*/
|
|
MIO_EXPORT mio_htb_t* mio_htb_open (
|
|
mio_t* mio,
|
|
mio_oow_t xtnsize, /**< extension size in bytes */
|
|
mio_oow_t capa, /**< initial capacity */
|
|
int factor, /**< load factor */
|
|
int kscale, /**< key scale - 1 to 255 */
|
|
int vscale /**< value scale - 1 to 255 */
|
|
);
|
|
|
|
|
|
/**
|
|
* The mio_htb_close() function destroys a hash table.
|
|
*/
|
|
MIO_EXPORT void mio_htb_close (
|
|
mio_htb_t* htb /**< hash table */
|
|
);
|
|
|
|
/**
|
|
* The mio_htb_init() function initializes a hash table
|
|
*/
|
|
MIO_EXPORT int mio_htb_init (
|
|
mio_htb_t* htb, /**< hash table */
|
|
mio_t* mio,
|
|
mio_oow_t capa, /**< initial capacity */
|
|
int factor, /**< load factor */
|
|
int kscale, /**< key scale */
|
|
int vscale /**< value scale */
|
|
);
|
|
|
|
/**
|
|
* The mio_htb_fini() funtion finalizes a hash table
|
|
*/
|
|
MIO_EXPORT void mio_htb_fini (
|
|
mio_htb_t* htb
|
|
);
|
|
|
|
#if defined(MIO_HAVE_INLINE)
|
|
static MIO_INLINE void* mio_htb_getxtn (mio_htb_t* htb) { return (void*)(htb + 1); }
|
|
#else
|
|
#define mio_htb_getxtn(htb) ((void*)((mio_htb_t*)(htb) + 1))
|
|
#endif
|
|
|
|
/**
|
|
* The mio_htb_getstyle() function gets manipulation callback function set.
|
|
*/
|
|
MIO_EXPORT const mio_htb_style_t* mio_htb_getstyle (
|
|
const mio_htb_t* htb /**< hash table */
|
|
);
|
|
|
|
/**
|
|
* The mio_htb_setstyle() function sets internal manipulation callback
|
|
* functions for data construction, destruction, resizing, hashing, etc.
|
|
* The callback structure pointed to by \a style must outlive the hash
|
|
* table pointed to by \a htb as the hash table doesn't copy the contents
|
|
* of the structure.
|
|
*/
|
|
MIO_EXPORT void mio_htb_setstyle (
|
|
mio_htb_t* htb, /**< hash table */
|
|
const mio_htb_style_t* style /**< callback function set */
|
|
);
|
|
|
|
/**
|
|
* The mio_htb_getsize() function gets the number of pairs in hash table.
|
|
*/
|
|
MIO_EXPORT mio_oow_t mio_htb_getsize (
|
|
const mio_htb_t* htb
|
|
);
|
|
|
|
/**
|
|
* The mio_htb_getcapa() function gets the number of slots allocated
|
|
* in a hash bucket.
|
|
*/
|
|
MIO_EXPORT mio_oow_t mio_htb_getcapa (
|
|
const mio_htb_t* htb /**< hash table */
|
|
);
|
|
|
|
/**
|
|
* The mio_htb_search() function searches a hash table to find a pair with a
|
|
* matching key. It returns the pointer to the pair found. If it fails
|
|
* to find one, it returns MIO_NULL.
|
|
* @return pointer to the pair with a maching key,
|
|
* or #MIO_NULL if no match is found.
|
|
*/
|
|
MIO_EXPORT mio_htb_pair_t* mio_htb_search (
|
|
const mio_htb_t* htb, /**< hash table */
|
|
const void* kptr, /**< key pointer */
|
|
mio_oow_t klen /**< key length */
|
|
);
|
|
|
|
/**
|
|
* The mio_htb_upsert() function searches a hash table for the pair with a
|
|
* matching key. If one is found, it updates the pair. Otherwise, it inserts
|
|
* a new pair with the key and value given. It returns the pointer to the
|
|
* pair updated or inserted.
|
|
* @return pointer to the updated or inserted pair on success,
|
|
* #MIO_NULL on failure.
|
|
*/
|
|
MIO_EXPORT mio_htb_pair_t* mio_htb_upsert (
|
|
mio_htb_t* htb, /**< hash table */
|
|
void* kptr, /**< key pointer */
|
|
mio_oow_t klen, /**< key length */
|
|
void* vptr, /**< value pointer */
|
|
mio_oow_t vlen /**< value length */
|
|
);
|
|
|
|
/**
|
|
* The mio_htb_ensert() function inserts a new pair with the key and the value
|
|
* given. If there exists a pair with the key given, the function returns
|
|
* the pair containing the key.
|
|
* @return pointer to a pair on success, #MIO_NULL on failure.
|
|
*/
|
|
MIO_EXPORT mio_htb_pair_t* mio_htb_ensert (
|
|
mio_htb_t* htb, /**< hash table */
|
|
void* kptr, /**< key pointer */
|
|
mio_oow_t klen, /**< key length */
|
|
void* vptr, /**< value pointer */
|
|
mio_oow_t vlen /**< value length */
|
|
);
|
|
|
|
/**
|
|
* The mio_htb_insert() function inserts a new pair with the key and the value
|
|
* given. If there exists a pair with the key given, the function returns
|
|
* #MIO_NULL without channging the value.
|
|
* @return pointer to the pair created on success, #MIO_NULL on failure.
|
|
*/
|
|
MIO_EXPORT mio_htb_pair_t* mio_htb_insert (
|
|
mio_htb_t* htb, /**< hash table */
|
|
void* kptr, /**< key pointer */
|
|
mio_oow_t klen, /**< key length */
|
|
void* vptr, /**< value pointer */
|
|
mio_oow_t vlen /**< value length */
|
|
);
|
|
|
|
/**
|
|
* The mio_htb_update() function updates the value of an existing pair
|
|
* with a matching key.
|
|
* @return pointer to the pair on success, #MIO_NULL on no matching pair
|
|
*/
|
|
MIO_EXPORT mio_htb_pair_t* mio_htb_update (
|
|
mio_htb_t* htb, /**< hash table */
|
|
void* kptr, /**< key pointer */
|
|
mio_oow_t klen, /**< key length */
|
|
void* vptr, /**< value pointer */
|
|
mio_oow_t vlen /**< value length */
|
|
);
|
|
|
|
/**
|
|
* The mio_htb_cbsert() function inserts a key/value pair by delegating pair
|
|
* allocation to a callback function. Depending on the callback function,
|
|
* it may behave like mio_htb_insert(), mio_htb_upsert(), mio_htb_update(),
|
|
* mio_htb_ensert(), or totally differently. The sample code below inserts
|
|
* a new pair if the key is not found and appends the new value to the
|
|
* existing value delimited by a comma if the key is found.
|
|
*
|
|
* @code
|
|
* #include <mio-htb.h>
|
|
*
|
|
* mio_htb_walk_t print_map_pair (mio_htb_t* map, mio_htb_pair_t* pair, void* ctx)
|
|
* {
|
|
* mio_printf (MIO_T("%.*s[%d] => %.*s[%d]\n"),
|
|
* MIO_HTB_KLEN(pair), MIO_HTB_KPTR(pair), (int)MIO_HTB_KLEN(pair),
|
|
* MIO_HTB_VLEN(pair), MIO_HTB_VPTR(pair), (int)MIO_HTB_VLEN(pair));
|
|
* return MIO_HTB_WALK_FORWARD;
|
|
* }
|
|
*
|
|
* mio_htb_pair_t* cbserter (
|
|
* mio_htb_t* htb, mio_htb_pair_t* pair,
|
|
* void* kptr, mio_oow_t klen, void* ctx)
|
|
* {
|
|
* mio_cstr_t* v = (mio_cstr_t*)ctx;
|
|
* if (pair == MIO_NULL)
|
|
* {
|
|
* // no existing key for the key
|
|
* return mio_htb_allocpair (htb, kptr, klen, v->ptr, v->len);
|
|
* }
|
|
* else
|
|
* {
|
|
* // a pair with the key exists.
|
|
* // in this sample, i will append the new value to the old value
|
|
* // separated by a comma
|
|
* mio_htb_pair_t* new_pair;
|
|
* mio_ooch_t comma = MIO_T(',');
|
|
* mio_uint8_t* vptr;
|
|
*
|
|
* // allocate a new pair, but without filling the actual value.
|
|
* // note vptr is given MIO_NULL for that purpose
|
|
* new_pair = mio_htb_allocpair (
|
|
* htb, kptr, klen, MIO_NULL, MIO_HTB_VLEN(pair) + 1 + v->len);
|
|
* if (new_pair == MIO_NULL) return MIO_NULL;
|
|
*
|
|
* // fill in the value space
|
|
* vptr = MIO_HTB_VPTR(new_pair);
|
|
* mio_memcpy (vptr, MIO_HTB_VPTR(pair), MIO_HTB_VLEN(pair)*MIO_SIZEOF(mio_ooch_t));
|
|
* vptr += MIO_HTB_VLEN(pair)*MIO_SIZEOF(mio_ooch_t);
|
|
* mio_memcpy (vptr, &comma, MIO_SIZEOF(mio_ooch_t));
|
|
* vptr += MIO_SIZEOF(mio_ooch_t);
|
|
* mio_memcpy (vptr, v->ptr, v->len*MIO_SIZEOF(mio_ooch_t));
|
|
*
|
|
* // this callback requires the old pair to be destroyed
|
|
* mio_htb_freepair (htb, pair);
|
|
*
|
|
* // return the new pair
|
|
* return new_pair;
|
|
* }
|
|
* }
|
|
*
|
|
* int main ()
|
|
* {
|
|
* mio_htb_t* s1;
|
|
* int i;
|
|
* mio_ooch_t* keys[] = { MIO_T("one"), MIO_T("two"), MIO_T("three") };
|
|
* mio_ooch_t* vals[] = { MIO_T("1"), MIO_T("2"), MIO_T("3"), MIO_T("4"), MIO_T("5") };
|
|
*
|
|
* mio_open_stdsios ();
|
|
* s1 = mio_htb_open (
|
|
* MIO_MMGR_GETDFL(), 0, 10, 70,
|
|
* MIO_SIZEOF(mio_ooch_t), MIO_SIZEOF(mio_ooch_t)
|
|
* ); // note error check is skipped
|
|
* mio_htb_setstyle (s1, mio_get_htb_style(MIO_HTB_STYLE_INLINE_COPIERS));
|
|
*
|
|
* for (i = 0; i < MIO_COUNTOF(vals); i++)
|
|
* {
|
|
* mio_cstr_t ctx;
|
|
* ctx.ptr = vals[i]; ctx.len = mio_count_oocstr(vals[i]);
|
|
* mio_htb_cbsert (s1,
|
|
* keys[i%MIO_COUNTOF(keys)], mio_count_oocstr(keys[i%MIO_COUNTOF(keys)]),
|
|
* cbserter, &ctx
|
|
* ); // note error check is skipped
|
|
* }
|
|
* mio_htb_walk (s1, print_map_pair, MIO_NULL);
|
|
*
|
|
* mio_htb_close (s1);
|
|
* mio_close_stdsios ();
|
|
* return 0;
|
|
* }
|
|
* @endcode
|
|
*/
|
|
MIO_EXPORT mio_htb_pair_t* mio_htb_cbsert (
|
|
mio_htb_t* htb, /**< hash table */
|
|
void* kptr, /**< key pointer */
|
|
mio_oow_t klen, /**< key length */
|
|
mio_htb_cbserter_t cbserter, /**< callback function */
|
|
void* ctx /**< callback context */
|
|
);
|
|
|
|
/**
|
|
* The mio_htb_delete() function deletes a pair with a matching key
|
|
* @return 0 on success, -1 on failure
|
|
*/
|
|
MIO_EXPORT int mio_htb_delete (
|
|
mio_htb_t* htb, /**< hash table */
|
|
const void* kptr, /**< key pointer */
|
|
mio_oow_t klen /**< key length */
|
|
);
|
|
|
|
/**
|
|
* The mio_htb_clear() function empties a hash table
|
|
*/
|
|
MIO_EXPORT void mio_htb_clear (
|
|
mio_htb_t* htb /**< hash table */
|
|
);
|
|
|
|
/**
|
|
* The mio_htb_walk() function traverses a hash table.
|
|
*/
|
|
MIO_EXPORT void mio_htb_walk (
|
|
mio_htb_t* htb, /**< hash table */
|
|
mio_htb_walker_t walker, /**< callback function for each pair */
|
|
void* ctx /**< pointer to user-specific data */
|
|
);
|
|
|
|
MIO_EXPORT void mio_init_htb_itr (
|
|
mio_htb_itr_t* itr
|
|
);
|
|
|
|
/**
|
|
* The mio_htb_getfirstpair() function returns the pointer to the first pair
|
|
* in a hash table.
|
|
*/
|
|
MIO_EXPORT mio_htb_pair_t* mio_htb_getfirstpair (
|
|
mio_htb_t* htb, /**< hash table */
|
|
mio_htb_itr_t* itr /**< iterator*/
|
|
);
|
|
|
|
/**
|
|
* The mio_htb_getnextpair() function returns the pointer to the next pair
|
|
* to the current pair @a pair in a hash table.
|
|
*/
|
|
MIO_EXPORT mio_htb_pair_t* mio_htb_getnextpair (
|
|
mio_htb_t* htb, /**< hash table */
|
|
mio_htb_itr_t* itr /**< iterator*/
|
|
);
|
|
|
|
/**
|
|
* The mio_htb_allocpair() function allocates a pair for a key and a value
|
|
* given. But it does not chain the pair allocated into the hash table @a htb.
|
|
* Use this function at your own risk.
|
|
*
|
|
* Take note of he following special behavior when the copier is
|
|
* #MIO_HTB_COPIER_INLINE.
|
|
* - If @a kptr is #MIO_NULL, the key space of the size @a klen is reserved but
|
|
* not propagated with any data.
|
|
* - If @a vptr is #MIO_NULL, the value space of the size @a vlen is reserved
|
|
* but not propagated with any data.
|
|
*/
|
|
MIO_EXPORT mio_htb_pair_t* mio_htb_allocpair (
|
|
mio_htb_t* htb,
|
|
void* kptr,
|
|
mio_oow_t klen,
|
|
void* vptr,
|
|
mio_oow_t vlen
|
|
);
|
|
|
|
/**
|
|
* The mio_htb_freepair() function destroys a pair. But it does not detach
|
|
* the pair destroyed from the hash table @a htb. Use this function at your
|
|
* own risk.
|
|
*/
|
|
MIO_EXPORT void mio_htb_freepair (
|
|
mio_htb_t* htb,
|
|
mio_htb_pair_t* pair
|
|
);
|
|
|
|
/**
|
|
* The mio_htb_dflhash() function is a default hash function.
|
|
*/
|
|
MIO_EXPORT mio_oow_t mio_htb_dflhash (
|
|
const mio_htb_t* htb,
|
|
const void* kptr,
|
|
mio_oow_t klen
|
|
);
|
|
|
|
/**
|
|
* The mio_htb_dflcomp() function is default comparator.
|
|
*/
|
|
MIO_EXPORT int mio_htb_dflcomp (
|
|
const mio_htb_t* htb,
|
|
const void* kptr1,
|
|
mio_oow_t klen1,
|
|
const void* kptr2,
|
|
mio_oow_t klen2
|
|
);
|
|
|
|
#if defined(__cplusplus)
|
|
}
|
|
#endif
|
|
|
|
#endif
|