1  #ifndef __CMPH_H__
       2  #define __CMPH_H__
       3  
       4  #include <stdlib.h>
       5  #include <stdio.h>
       6  
       7  #ifdef __cplusplus
       8  extern "C"
       9  {
      10  #endif
      11  
      12  #include "cmph_types.h"
      13  
      14  typedef struct __config_t cmph_config_t;
      15  typedef struct __cmph_t cmph_t;
      16  
      17  typedef struct 
      18  {
      19          void *data;
      20          cmph_uint32 nkeys;
      21          int (*read)(void *, char **, cmph_uint32 *);
      22          void (*dispose)(void *, char *, cmph_uint32);
      23          void (*rewind)(void *);
      24  } cmph_io_adapter_t;
      25  
      26  /** Adapter pattern API **/
      27  /* please call free() in the created adapters */
      28  cmph_io_adapter_t *cmph_io_nlfile_adapter(FILE * keys_fd);
      29  void cmph_io_nlfile_adapter_destroy(cmph_io_adapter_t * key_source);
      30  
      31  cmph_io_adapter_t *cmph_io_nlnkfile_adapter(FILE * keys_fd, cmph_uint32 nkeys);
      32  void cmph_io_nlnkfile_adapter_destroy(cmph_io_adapter_t * key_source);
      33  
      34  cmph_io_adapter_t *cmph_io_vector_adapter(char ** vector, cmph_uint32 nkeys);
      35  void cmph_io_vector_adapter_destroy(cmph_io_adapter_t * key_source);
      36  
      37  cmph_io_adapter_t *cmph_io_byte_vector_adapter(cmph_uint8 ** vector, cmph_uint32 nkeys);
      38  void cmph_io_byte_vector_adapter_destroy(cmph_io_adapter_t * key_source);
      39  
      40  cmph_io_adapter_t *cmph_io_struct_vector_adapter(void * vector, 
      41                                                   cmph_uint32 struct_size, 
      42                                                   cmph_uint32 key_offset, 
      43                                                   cmph_uint32 key_len, 
      44                                                   cmph_uint32 nkeys);
      45  
      46  void cmph_io_struct_vector_adapter_destroy(cmph_io_adapter_t * key_source);
      47  
      48  /** Hash configuration API **/
      49  cmph_config_t *cmph_config_new(cmph_io_adapter_t *key_source);
      50  void cmph_config_set_hashfuncs(cmph_config_t *mph, CMPH_HASH *hashfuncs);
      51  void cmph_config_set_verbosity(cmph_config_t *mph, cmph_uint32 verbosity);
      52  void cmph_config_set_graphsize(cmph_config_t *mph, double c);
      53  void cmph_config_set_algo(cmph_config_t *mph, CMPH_ALGO algo);
      54  void cmph_config_set_tmp_dir(cmph_config_t *mph, cmph_uint8 *tmp_dir);
      55  void cmph_config_set_mphf_fd(cmph_config_t *mph, FILE *mphf_fd);
      56  void cmph_config_set_b(cmph_config_t *mph, cmph_uint32 b);
      57  void cmph_config_set_keys_per_bin(cmph_config_t *mph, cmph_uint32 keys_per_bin);
      58  void cmph_config_set_memory_availability(cmph_config_t *mph, cmph_uint32 memory_availability);
      59  void cmph_config_destroy(cmph_config_t *mph);
      60  
      61  /** Hash API **/
      62  cmph_t *cmph_new(cmph_config_t *mph);
      63  
      64  /** cmph_uint32 cmph_search(cmph_t *mphf, const char *key, cmph_uint32 keylen);
      65   *  \brief Computes the mphf value. 
      66   *  \param mphf pointer to the resulting function
      67   *  \param key is the key to be hashed
      68   *  \param keylen is the key legth in bytes
      69   *  \return The mphf value
      70   */
      71  cmph_uint32 cmph_search(cmph_t *mphf, const char *key, cmph_uint32 keylen);
      72  
      73  cmph_uint32 cmph_size(cmph_t *mphf);
      74  void cmph_destroy(cmph_t *mphf);
      75  
      76  /** Hash serialization/deserialization */
      77  int cmph_dump(cmph_t *mphf, FILE *f);
      78  cmph_t *cmph_load(FILE *f);
      79  
      80  /** \fn void cmph_pack(cmph_t *mphf, void *packed_mphf);
      81   *  \brief Support the ability to pack a perfect hash function into a preallocated contiguous memory space pointed by packed_mphf.
      82   *  \param mphf pointer to the resulting mphf
      83   *  \param packed_mphf pointer to the contiguous memory area used to store the 
      84   *  \param resulting mphf. The size of packed_mphf must be at least cmph_packed_size() 
      85   */
      86  void cmph_pack(cmph_t *mphf, void *packed_mphf);
      87  
      88  /** \fn cmph_uint32 cmph_packed_size(cmph_t *mphf);
      89   *  \brief Return the amount of space needed to pack mphf.
      90   *  \param mphf pointer to a mphf
      91   *  \return the size of the packed function or zero for failures
      92   */
      93  cmph_uint32 cmph_packed_size(cmph_t *mphf);
      94  
      95  /** cmph_uint32 cmph_search(void *packed_mphf, const char *key, cmph_uint32 keylen);
      96   *  \brief Use the packed mphf to do a search. 
      97   *  \param  packed_mphf pointer to the packed mphf
      98   *  \param key key to be hashed
      99   *  \param keylen key legth in bytes
     100   *  \return The mphf value
     101   */
     102  cmph_uint32 cmph_search_packed(void *packed_mphf, const char *key, cmph_uint32 keylen);
     103  
     104  // TIMING functions. To use the macro CMPH_TIMING must be defined
     105  #include "cmph_time.h"
     106  
     107  
     108  #ifdef __cplusplus
     109  }
     110  #endif
     111  
     112  #endif