mmpd_adapter/fpcm/coucal.h

Go to the documentation of this file.

/* ------------------------------------------------------------ */
/*
Coucal, Cuckoo hashing-based hashtable with stash area.
Copyright (C) 2013-2014 Xavier Roche (http://www.httrack.com/)
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.

3. Neither the name of the copyright holder 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 HOLDER 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.
*/

#ifndef COUCAL_DEFH
#define COUCAL_DEFH

/* Includes */
#ifdef _WIN32
#include <stddef.h>
typedef unsigned __int32 uint32_t;
typedef unsigned __int64 uint64_t;
#elif (defined(SOLARIS) || defined(sun) || defined(HAVE_INTTYPES_H) \
  || defined(BSD) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) || defined(__FreeBSD_kernel__))
#include <inttypes.h>
#else
#include <stdint.h>
#endif
#include <stdarg.h>

/* External definitions */
#ifndef COUCAL_EXTERN
#ifdef _WIN32
#ifdef COUCAL_BUILDING
#define COUCAL_EXTERN __declspec(dllimport)
#else
#define COUCAL_EXTERN __declspec(dllexport)
#endif
#elif ( ( defined(__GNUC__) && ( __GNUC__ >= 4 ) ) \
        || ( defined(HAVE_VISIBILITY) && HAVE_VISIBILITY ) )
#define COUCAL_EXTERN extern __attribute__ ((visibility("default")))
#else
#define COUCAL_EXTERN extern
#endif
#endif

typedef void* coucal_key;

typedef const void* coucal_key_const;

typedef void* coucal_opaque;

typedef union coucal_value {
  intptr_t intg;

  uintptr_t uintg;

  void *ptr;
} coucal_value;

typedef const coucal_value coucal_value_const;

#define INTHASH_VALUE_NULL { 0 }

#ifndef HTS_DEF_FWSTRUCT_coucal_item
#define HTS_DEF_FWSTRUCT_coucal_item
typedef struct coucal_item coucal_item;
#endif

#ifndef COUCAL_HASH_SIZE
#define COUCAL_HASH_SIZE 32
#endif

#if (COUCAL_HASH_SIZE == 32)

typedef uint32_t coucal_hashkey;

#elif (COUCAL_HASH_SIZE == 64)

typedef uint64_t coucal_hashkey;

#else
#error "Unsupported COUCAL_HASH_SIZE"
#endif

typedef struct coucal_hashkeys {
  coucal_hashkey hash1;
  coucal_hashkey hash2;
} coucal_hashkeys;

#define INTHASH_KEYS_NULL { 0, 0 }

struct coucal_item {
  coucal_key name;

  coucal_value value;

  coucal_hashkeys hashes;
};

typedef enum coucal_loglevel {
  coucal_log_critical,
  coucal_log_warning,
  coucal_log_info,
  coucal_log_debug,
  coucal_log_trace
} coucal_loglevel;

typedef void (*t_coucal_key_freehandler)(coucal_opaque arg,
                                         coucal_key key);

typedef void (*t_coucal_value_freehandler)(coucal_opaque arg,
                                           coucal_value value);

typedef coucal_key (*t_coucal_duphandler)(coucal_opaque arg,
                                          coucal_key_const name);

typedef coucal_hashkeys (*t_coucal_hasheshandler)(coucal_opaque arg,
                                                  coucal_key_const name);

typedef void (*t_coucal_loghandler)(coucal_opaque arg, coucal_loglevel level, 
                                    const char* format, va_list args);

typedef void (*t_coucal_asserthandler)(coucal_opaque arg, const char* exp,
                                       const char* file, int line);

typedef const char* (*t_coucal_printkeyhandler)(coucal_opaque arg,
                                                coucal_key_const name);

typedef const char* (*t_coucal_printvaluehandler)(coucal_opaque arg,
                                                  coucal_value_const value);

typedef int (*t_coucal_cmphandler)(coucal_opaque arg,
                                   coucal_key_const a,
                                   coucal_key_const b);

#ifndef HTS_DEF_FWSTRUCT_struct_coucal
#define HTS_DEF_FWSTRUCT_struct_coucal
typedef struct struct_coucal struct_coucal, *coucal;
#endif

#ifndef HTS_DEF_FWSTRUCT_struct_coucal_enum
#define HTS_DEF_FWSTRUCT_struct_coucal_enum
typedef struct struct_coucal_enum struct_coucal_enum;
#endif

struct struct_coucal_enum {
  coucal table;
  size_t index;
};

#ifdef __cplusplus
extern "C" {
#endif

COUCAL_EXTERN coucal coucal_new(size_t size);

COUCAL_EXTERN int coucal_created(coucal hashtable);

COUCAL_EXTERN void coucal_delete(coucal * hashtable);

COUCAL_EXTERN size_t coucal_nitems(coucal hashtable);

COUCAL_EXTERN size_t coucal_memory_size(coucal hashtable);

COUCAL_EXTERN size_t coucal_hash_size(void);

COUCAL_EXTERN void coucal_value_is_malloc(coucal hashtable, int flag);

COUCAL_EXTERN void coucal_value_set_value_handler(coucal hashtable,
                                                  t_coucal_value_freehandler free,
                                                  coucal_opaque arg);

COUCAL_EXTERN void coucal_value_set_key_handler(coucal hashtable,
                                                t_coucal_duphandler dup,
                                                t_coucal_key_freehandler free,
                                                t_coucal_hasheshandler hash,
                                                t_coucal_cmphandler equals,
                                                coucal_opaque arg);

COUCAL_EXTERN void coucal_set_assert_handler(coucal hashtable,
                                             t_coucal_loghandler log,
                                             t_coucal_asserthandler fatal,
                                             coucal_opaque arg);

COUCAL_EXTERN void coucal_set_print_handler(coucal hashtable,
                                            t_coucal_printkeyhandler key,
                                            t_coucal_printvaluehandler value,
                                            coucal_opaque arg);

COUCAL_EXTERN void coucal_set_name(coucal hashtable, coucal_key_const name);

COUCAL_EXTERN const char* coucal_get_name(coucal hashtable);

COUCAL_EXTERN int coucal_read(coucal hashtable, coucal_key_const name,
                              intptr_t * intvalue);

COUCAL_EXTERN int coucal_readptr(coucal hashtable, coucal_key_const name,
                                 intptr_t * intvalue);

COUCAL_EXTERN intptr_t coucal_get_intptr(coucal hashtable,
                                         coucal_key_const name);

COUCAL_EXTERN int coucal_exists(coucal hashtable, coucal_key_const name);

COUCAL_EXTERN int coucal_read_value(coucal hashtable, coucal_key_const name,
                                    coucal_value *value);

COUCAL_EXTERN int coucal_write_value(coucal hashtable, coucal_key_const name,
                                     coucal_value_const value);

COUCAL_EXTERN int coucal_read_pvoid(coucal hashtable, coucal_key_const name,
                                    void **value);

COUCAL_EXTERN void* coucal_get_pvoid(coucal hashtable, coucal_key_const name);

COUCAL_EXTERN int coucal_write_pvoid(coucal hashtable, coucal_key_const name,
                                     void *value);

COUCAL_EXTERN void coucal_add_pvoid(coucal hashtable, coucal_key_const name,
                                    void *value);

COUCAL_EXTERN int coucal_write(coucal hashtable, coucal_key_const name,
                               intptr_t value);

COUCAL_EXTERN void coucal_add(coucal hashtable, coucal_key_const name,
                              intptr_t value);

COUCAL_EXTERN int coucal_inc(coucal hashtable, coucal_key_const name);

COUCAL_EXTERN int coucal_dec(coucal hashtable, coucal_key_const name);

COUCAL_EXTERN coucal_value* coucal_fetch_value(coucal hashtable,
                                               coucal_key_const name);

COUCAL_EXTERN coucal_value* coucal_fetch_value_hashes(coucal hashtable,
                                                      coucal_key_const name,
                                                      const coucal_hashkeys
                                                      *hashes);

COUCAL_EXTERN int coucal_remove(coucal hashtable, coucal_key_const name);

COUCAL_EXTERN struct_coucal_enum coucal_enum_new(coucal hashtable);

COUCAL_EXTERN coucal_item *coucal_enum_next(struct_coucal_enum * e);

COUCAL_EXTERN coucal_hashkeys coucal_calc_hashes(coucal hashtable, 
                                                 coucal_key_const value);

COUCAL_EXTERN coucal_hashkeys coucal_hash_string(const char *value);

COUCAL_EXTERN coucal_hashkeys coucal_hash_data(const void *data, size_t size);

COUCAL_EXTERN void coucal_set_global_assert_handler(t_coucal_loghandler log,
                                                    t_coucal_asserthandler fatal);

#ifdef __cplusplus
}
#endif

#endif

---