plucky (3) libhashkit.3.gz

Provided by: libhashkit-dev_1.1.4-1.1build3_amd64 bug

NAME

       libhashkit - libhashkit Documentation

SYNOPSIS

       #include <libhashkit-1.0/hashkit.h>
              Compile and link with -lhashkit.

DESCRIPTION

       libhashkit  is  a  small  and  thread-safe  client  library  that provides a collection of useful hashing
       algorithms.

       libhashkit is distributed with libmemcached.

   Creating a hashkit structure
   SYNOPSIS
       #include <libhashkit-1.0/hashkit.h>
              Compile and link with -lhashkit

       typedef struct hashkit_st hashkit_st

       hashkit_st *hashkit_create(hashkit_st *hash)

              Parameters
                     hash -- memory address of a hashkit_st struct; if a nullptr is passed, the struct  will  be
                     dynamically allocated by libhashkit

              Returns
                     pointer to initialized hashkit_st structure

       hashkit_st *hashkit_clone(hashkit_st *destination, const hashkit_st *ptr)

              Parametersdestination  -- memory address of a hashkit_st struct; if a nullptr is passed, the struct
                       will be dynamically allocated by libhashkit

                     • ptr -- pointer of the hashkit_st struct to copy

              Returns
                     pointer to a hashkit_st structure (destination, if not nullptr), initialized from ptr

       void hashkit_free(hashkit_st *hash)

              Parameters
                     hash -- pointer to an initialized hashkit_st struct

       bool hashkit_is_allocated(const hashkit_st *hash)

              Parameters
                     hash -- pointer to an initialized hashkit_st struct

              Returns
                     bool, whether the hash struct was dynamically allocated

   DESCRIPTION
       The hashkit_create() function initializes a hashkit object for use. If you pass a  nullptr  argument  for
       hash,  then  the memory for the object is allocated. If you specify a pre-allocated piece of memory, that
       is initialized for use.

       The hashkit_clone() function initializes a hashkit object much  like  hashkit_create(),  but  instead  of
       using default settings it will use the settings of the ptr hashkit object.

       The  hashkit_free()  frees any resources being consumed by the hashkit objects that were initialized with
       hashkit_create() or hashkit_clone().

       The hashkit_is_allocated() reports whether the memory was allocated for a hashkit object.

   RETURN VALUE
       hashkit_create() and hashkit_clone() will return nullptr on failure or pointer to hashkit_st on success.

       hashkit_is_allocated() returns true if the  memory  for  the  hashkit  object  was  allocated  inside  of
       hashkit_create() or hashkit_clone(), otherwise it is false and was user-supplied memory.

   SEE ALSO
       libhashkit(3) hashkit_value(3) hashkit_function3)

   Set Hash Function
   SYNOPSIS
       #include <libhashkit-1.0/hashkit.h>
              Compile and link with -lhashkit

       typedef uint32_t (*hashkit_hash_fn)(const char *key, size_t key_length, void *context)

              Param key
                     the key to generate a hash of

              Param key_length
                     the length of the key without any terminating zero byte

              Param context
                     the   custom   hash   function   context   set   through  hashkit_set_custom_function()  or
                     hashkit_set_custom_distribution_function()

              Returns
                     the custom hash function should return a hash value for key as an unsigned 32bit integer

       typedef enum hashkit_return_t hashkit_return_t

       enum hashkit_return_t

              enumerator HASHKIT_SUCCESS
                     Operation succeeded.

              enumerator HASHKIT_FAILURE
                     Operation failed.

              enumerator HASHKIT_MEMORY_ALLOCATION_FAILURE
                     Memory allocation failed.

              enumerator HASHKIT_INVALID_HASH
                     Invalid hashkit_hash_algorithm_t passed.

              enumerator HASHKIT_INVALID_ARGUMENT
                     Invalid argument passed.

       typedef enum hashkit_hash_algorithm_t hashkit_hash_algorithm_t

       enum hashkit_hash_algorithm_t

              enumerator HASHKIT_HASH_DEFAULT
                     Default hash algorithm (one_at_a_time).

              enumerator HASHKIT_HASH_MD5

              enumerator HASHKIT_HASH_CRC

              enumerator HASHKIT_HASH_FNV1_64

              enumerator HASHKIT_HASH_FNV1A_64

              enumerator HASHKIT_HASH_FNV1_32

              enumerator HASHKIT_HASH_FNV1A_32

              enumerator HASHKIT_HASH_HSIEH
                     Only available if libhashkit hash been built with HSIEH support.

              enumerator HASHKIT_HASH_MURMUR
                     Only available if libhashkit has been built with MURMUR support.

              enumerator HASHKIT_HASH_MURMUR3
                     Only available if libhashkit has been built with MURMUR support.

              enumerator HASHKIT_HASH_JENKINS

              enumerator HASHKIT_HASH_CUSTOM
                     Use  custom  hashkit_hash_fn  function   set   through   hashkit_set_custom_function()   or
                     hashkit_set_custom_distribution_function().

       hashkit_return_t hashkit_set_function(hashkit_st *hash, hashkit_hash_algorithm_t hash_algorithm)

              Parametershash -- pointer to an initialized hashkit_st struct

                     • hash_algorithm -- valid hashkit_hash_algorithm_t constant

              Returns
                     hashkit_return_t indicating success or failure

       hashkit_return_t hashkit_set_custom_function(hashkit_st *hash, hashkit_hash_fn function, void *context)

              Parametershash -- pointer to initialized hashkit_st struct

                     • function   --   hashkit_hash_fn   function   pointer   to   use   as  hash  function  for
                       HASHKIT_HASH_CUSTOMcontext -- pointer to an opaque user managed context for the custom hash function

              Returns
                     hashkit_return_t indicating success or failure

       hashkit_hash_algorithm_t hashkit_get_function(const hashkit_st *hash)

              Parameters
                     hash -- pointer to an initialized hashkit_st struct

              Returns
                     hashkit_hash_algorithm_t indicating the currently set hash algorithm to use

       hashkit_return_t     hashkit_set_distribution_function(hashkit_st     *hash,     hashkit_hash_algorithm_t
       hash_algorithm)

              Parametershash -- pointer to an initialized hashkit_st struct

                     • hash_algorithm -- valid hashkit_hash_algrothm_t constant

              Returns
                     hashkit_return_t indicating success or failure

       hashkit_return_t  hashkit_set_custom_distribution_function(hashkit_st  *hash,  hashkit_hash_fn  function,
       void *context)

              Parametershash -- pointer to initialized hashkit_st struct

                     • function -- hashkit_hash_fn function pointer to use as  distribution  hash  function  for
                       HASHKIT_HASH_CUSTOMcontext  --  pointer  to  an opaque user managed context for the custom distribution hash
                       function

       hashkit_hash_algorithm_t hashkit_get_distribution_function(const hashkit_st *hash)

              Parameters
                     hash -- pointer to an initialized hashkit_st struct

              Returns
                     hashkit_hash_algorithm_t indicating the currently set distribution hash algorithm to use

   DESCRIPTION
       These functions are used to set and retrieve the key and distribution hash functions.

   RETURN VALUE
       hashkit_set_function(),   hashkit_set_custom_function()   and   the   distribution   equivalents   return
       hashkit_return_t::HASHKIT_SUCCESS on success.

       hashkit_get_function() and hashkit_get_distribution_function() return hashkit_hash_algorithm_t indicating
       the hash function used.

   SEE ALSO
       libhashkit(3) hashkit_create(3) hashkit_functions(3)

   Available Hashes
   SYNOPSIS
       #include <libhashkit-1.0/hashkit.h>
              Compile and link with -lhashkit

       uint32_t hashkit_default(const char *key, size_t key_length)

       uint32_t hashkit_fnv1_64(const char *key, size_t key_length)

       uint32_t hashkit_fnv1a_64(const char *key, size_t key_length)

       uint32_t hashkit_fnv1_32(const char *key, size_t key_length)

       uint32_t hashkit_fnv1a_32(const char *key, size_t key_length)

       uint32_t hashkit_crc32(const char *key, size_t key_length)

       uint32_t hashkit_hsieh(const char *key, size_t key_length)

       uint32_t hashkit_murmur(const char *key, size_t key_length)

       uint32_t hashkit_murmur3(const char *key, size_t key_length)

       uint32_t hashkit_jenkins(const char *key, size_t key_length)

       uint32_t hashkit_md5(const char *key, size_t key_length)

   DESCRIPTION
       These functions generate hash values from a key using a variety of algorithms.  These  functions  can  be
       used  standalone,  or  will  be  used  according  to  the  algorithm  set  with hashkit_set_function() or
       hashkit_set_distribution_function().

       The hashkit_hsieh(), hashkit_murmur() and hashkit_murmur3() functions are only available if  the  library
       is built with the appropriate flag enabled.

   RETURN VALUE
       A 32-bit hash value.

   SEE ALSO
       libhashkit(3) hashkit_create(3) hashkit_function(3)

   Generate hash value
   SYNOPSIS
       #include <libhashkit-1.0/hashkit.h>
              Compile and link with -lhashkit

       uint32_t hashkit_value(hashkit_st *hash, const char *key, size_t key_length)

              Parametershash -- pointer to an initialized hashkit_st struct

                     • key -- the key to genereate a hash of

                     • key_length -- the length of the key without any terminating zero byte

   DESCRIPTION
       The  hashkit_value()  function  generates a 32-bit hash value from the given key and key_length. The hash
       argument is an initialized hashkit object, and distribution type and hash  function  is  used  from  this
       object while generating the value.

   RETURN VALUE
       A 32-bit hash value.

   SEE ALSO
       libhashkit(3) hashkit_create(3) hashkit_function(3) hashkit_functions(3)

SEE ALSO

       libmemcached(3) hashkit_create(3) hashkit_function(3) hashkit_functions(3) hashkit_value(3)