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
113