1
Fork 0
turbonss/src/cmph.c

498 lines
11 KiB
C
Raw Normal View History

2004-12-23 15:16:30 +02:00
#include "cmph.h"
#include "cmph_structs.h"
2005-01-25 23:06:58 +02:00
#include "chm.h"
2004-12-23 15:16:30 +02:00
#include "bmz.h"
#include "bmz8.h" /* included -- Fabiano */
#include "brz.h" /* included -- Fabiano */
2004-12-23 15:16:30 +02:00
#include <stdlib.h>
#include <assert.h>
#include <string.h>
2004-12-23 15:16:30 +02:00
//#define DEBUG
#include "debug.h"
const char *cmph_names[] = { "bmz", "bmz8", "chm", "brz", NULL }; /* included -- Fabiano */
2004-12-23 15:16:30 +02:00
2005-10-10 20:43:21 +03:00
typedef struct
{
void *vector;
cmph_uint32 position; // access position when data is a vector
} cmph_vector_t;
static cmph_io_adapter_t *cmph_io_vector_new(void * vector, cmph_uint32 nkeys);
static void cmph_io_vector_destroy(cmph_io_adapter_t * key_source);
2005-07-26 00:26:17 +03:00
2005-01-24 22:25:58 +02:00
static int key_nlfile_read(void *data, char **key, cmph_uint32 *keylen)
{
FILE *fd = (FILE *)data;
*key = NULL;
*keylen = 0;
while(1)
{
char buf[BUFSIZ];
char *c = fgets(buf, BUFSIZ, fd);
if (c == NULL) return -1;
if (feof(fd)) return -1;
*key = (char *)realloc(*key, *keylen + strlen(buf) + 1);
memcpy(*key + *keylen, buf, strlen(buf));
*keylen += (cmph_uint32)strlen(buf);
if (buf[strlen(buf) - 1] != '\n') continue;
break;
}
if ((*keylen) && (*key)[*keylen - 1] == '\n')
{
(*key)[(*keylen) - 1] = 0;
--(*keylen);
}
return *keylen;
}
2005-07-26 00:26:17 +03:00
static int key_vector_read(void *data, char **key, cmph_uint32 *keylen)
{
/*
cmph_vector_t *cmph_vector = (cmph_vector_t *)data;
2005-10-10 20:43:21 +03:00
char **keys_vd = (char **)cmph_vector->vector;
2005-07-29 03:00:01 +03:00
2005-10-10 20:43:21 +03:00
if (keys_vd + cmph_vector->position == NULL) return -1;
*keylen = strlen(*(keys_vd + cmph_vector->position));
2005-07-29 03:00:01 +03:00
*key = (char *)malloc(*keylen + 1);
2005-10-10 20:43:21 +03:00
strcpy(*key, *(keys_vd + cmph_vector->position));
cmph_vector->position = cmph_vector->position + 1;
*/
cmph_vector_t *cmph_vector = (cmph_vector_t *)data;
char **keys_vd = (char **)cmph_vector->vector;
// if (keys_vd + cmph_vector->position == NULL) return -1;
*keylen = strlen(keys_vd[cmph_vector->position]);
*key = (char *)malloc(*keylen + 1);
strcpy(*key, keys_vd[cmph_vector->position]);
cmph_vector->position = cmph_vector->position + 1;
2005-07-26 00:26:17 +03:00
return *keylen;
2005-07-26 00:26:17 +03:00
}
2005-01-24 22:25:58 +02:00
static void key_nlfile_dispose(void *data, char *key, cmph_uint32 keylen)
{
free(key);
}
2005-07-26 00:26:17 +03:00
2005-07-29 03:00:01 +03:00
static void key_vector_dispose(void *data, char *key, cmph_uint32 keylen)
{
free(key);
2005-07-29 03:00:01 +03:00
}
2005-01-24 22:25:58 +02:00
static void key_nlfile_rewind(void *data)
{
FILE *fd = (FILE *)data;
rewind(fd);
}
2005-07-26 00:26:17 +03:00
static void key_vector_rewind(void *data)
{
2005-10-10 20:43:21 +03:00
cmph_vector_t *cmph_vector = (cmph_vector_t *)data;
cmph_vector->position = 0;
2005-07-26 00:26:17 +03:00
}
2005-01-24 22:25:58 +02:00
static cmph_uint32 count_nlfile_keys(FILE *fd)
{
cmph_uint32 count = 0;
rewind(fd);
while(1)
{
char buf[BUFSIZ];
fgets(buf, BUFSIZ, fd);
if (feof(fd)) break;
if (buf[strlen(buf) - 1] != '\n') continue;
++count;
}
rewind(fd);
return count;
}
cmph_io_adapter_t *cmph_io_nlfile_adapter(FILE * keys_fd)
{
cmph_io_adapter_t * key_source = (cmph_io_adapter_t *)malloc(sizeof(cmph_io_adapter_t));
2005-01-24 22:25:58 +02:00
assert(key_source);
key_source->data = (void *)keys_fd;
key_source->nkeys = count_nlfile_keys(keys_fd);
key_source->read = key_nlfile_read;
key_source->dispose = key_nlfile_dispose;
key_source->rewind = key_nlfile_rewind;
return key_source;
}
2005-10-10 20:43:21 +03:00
void cmph_io_nlfile_adapter_destroy(cmph_io_adapter_t * key_source)
{
free(key_source);
}
2005-01-24 22:25:58 +02:00
cmph_io_adapter_t *cmph_io_nlnkfile_adapter(FILE * keys_fd, cmph_uint32 nkeys)
{
cmph_io_adapter_t * key_source = (cmph_io_adapter_t *)malloc(sizeof(cmph_io_adapter_t));
2005-01-24 22:25:58 +02:00
assert(key_source);
key_source->data = (void *)keys_fd;
key_source->nkeys = nkeys;
key_source->read = key_nlfile_read;
key_source->dispose = key_nlfile_dispose;
key_source->rewind = key_nlfile_rewind;
return key_source;
}
2005-10-10 20:43:21 +03:00
void cmph_io_nlnkfile_adapter_destroy(cmph_io_adapter_t * key_source)
{
free(key_source);
}
static cmph_io_adapter_t *cmph_io_vector_new(void * vector, cmph_uint32 nkeys)
{
cmph_io_adapter_t * key_source = (cmph_io_adapter_t *)malloc(sizeof(cmph_io_adapter_t));
cmph_vector_t * cmph_vector = (cmph_vector_t *)malloc(sizeof(cmph_vector_t));
2005-10-10 20:43:21 +03:00
assert(key_source);
assert(cmph_vector);
cmph_vector->vector = vector;
cmph_vector->position = 0;
key_source->data = (void *)cmph_vector;
key_source->nkeys = nkeys;
return key_source;
}
static void cmph_io_vector_destroy(cmph_io_adapter_t * key_source)
{
cmph_vector_t *cmph_vector = (cmph_vector_t *)key_source->data;
cmph_vector->vector = NULL;
free(cmph_vector);
free(key_source);
}
2005-07-28 00:13:02 +03:00
cmph_io_adapter_t *cmph_io_vector_adapter(char ** vector, cmph_uint32 nkeys)
2005-01-24 22:25:58 +02:00
{
2005-10-10 20:43:21 +03:00
cmph_io_adapter_t * key_source = cmph_io_vector_new(vector, nkeys);
key_source->read = key_vector_read;
key_source->dispose = key_vector_dispose;
key_source->rewind = key_vector_rewind;
return key_source;
}
void cmph_io_vector_adapter_destroy(cmph_io_adapter_t * key_source)
{
cmph_io_vector_destroy(key_source);
2005-01-24 22:25:58 +02:00
}
cmph_config_t *cmph_config_new(cmph_io_adapter_t *key_source)
2004-12-23 15:16:30 +02:00
{
cmph_config_t *mph = NULL;
mph = __config_new(key_source);
2004-12-23 15:16:30 +02:00
assert(mph);
2005-01-25 23:06:58 +02:00
mph->algo = CMPH_CHM; // default value
mph->data = chm_config_new();
2004-12-23 15:16:30 +02:00
return mph;
}
void cmph_config_set_algo(cmph_config_t *mph, CMPH_ALGO algo)
{
if (algo != mph->algo)
{
switch (mph->algo)
{
case CMPH_CHM:
2005-07-29 03:00:01 +03:00
chm_config_destroy(mph);
2005-07-28 00:13:02 +03:00
break;
case CMPH_BMZ:
2005-07-29 03:00:01 +03:00
bmz_config_destroy(mph);
2005-07-28 00:13:02 +03:00
break;
case CMPH_BMZ8:
bmz8_config_destroy(mph);
break;
2005-07-28 00:13:02 +03:00
case CMPH_BRZ:
brz_config_destroy(mph);
2005-07-28 00:13:02 +03:00
break;
default:
2005-07-28 00:13:02 +03:00
assert(0);
}
switch(algo)
{
case CMPH_CHM:
2005-07-28 00:13:02 +03:00
mph->data = chm_config_new();
break;
case CMPH_BMZ:
2005-07-28 00:13:02 +03:00
mph->data = bmz_config_new();
break;
case CMPH_BMZ8:
2005-09-06 17:11:37 +03:00
mph->data = bmz8_config_new();
break;
2005-07-28 00:13:02 +03:00
case CMPH_BRZ:
mph->data = brz_config_new();
2005-09-06 17:11:37 +03:00
break;
default:
2005-07-28 00:13:02 +03:00
assert(0);
}
}
mph->algo = algo;
}
void cmph_config_set_tmp_dir(cmph_config_t *mph, cmph_uint8 *tmp_dir)
{
switch (mph->algo)
{
case CMPH_CHM:
break;
case CMPH_BMZ: /* included -- Fabiano */
break;
case CMPH_BMZ8: /* included -- Fabiano */
break;
case CMPH_BRZ: /* included -- Fabiano */
brz_config_set_tmp_dir(mph, tmp_dir);
break;
default:
assert(0);
}
}
void cmph_config_set_mphf_fd(cmph_config_t *mph, FILE *mphf_fd)
{
switch (mph->algo)
{
case CMPH_CHM:
break;
case CMPH_BMZ: /* included -- Fabiano */
break;
case CMPH_BMZ8: /* included -- Fabiano */
break;
case CMPH_BRZ: /* included -- Fabiano */
brz_config_set_mphf_fd(mph, mphf_fd);
break;
default:
assert(0);
}
}
void cmph_config_set_b(cmph_config_t *mph, cmph_uint8 b)
{
switch (mph->algo)
{
case CMPH_CHM:
break;
case CMPH_BMZ: /* included -- Fabiano */
break;
case CMPH_BMZ8: /* included -- Fabiano */
break;
case CMPH_BRZ: /* included -- Fabiano */
brz_config_set_b(mph, b);
break;
default:
assert(0);
}
}
void cmph_config_set_memory_availability(cmph_config_t *mph, cmph_uint32 memory_availability)
{
switch (mph->algo)
{
case CMPH_CHM:
break;
case CMPH_BMZ: /* included -- Fabiano */
break;
case CMPH_BMZ8: /* included -- Fabiano */
break;
case CMPH_BRZ: /* included -- Fabiano */
brz_config_set_memory_availability(mph, memory_availability);
break;
default:
assert(0);
}
}
void cmph_config_destroy(cmph_config_t *mph)
2004-12-23 15:16:30 +02:00
{
2005-01-18 23:06:08 +02:00
DEBUGP("Destroying mph with algo %s\n", cmph_names[mph->algo]);
2004-12-23 15:16:30 +02:00
switch (mph->algo)
{
2005-01-25 23:06:58 +02:00
case CMPH_CHM:
chm_config_destroy(mph);
2004-12-23 15:16:30 +02:00
break;
2005-01-18 23:06:08 +02:00
case CMPH_BMZ: /* included -- Fabiano */
2005-07-28 00:13:02 +03:00
bmz_config_destroy(mph);
break;
case CMPH_BMZ8: /* included -- Fabiano */
bmz8_config_destroy(mph);
break;
2005-07-28 00:13:02 +03:00
case CMPH_BRZ: /* included -- Fabiano */
brz_config_destroy(mph);
2005-09-06 17:11:37 +03:00
break;
2004-12-23 15:16:30 +02:00
default:
assert(0);
}
__config_destroy(mph);
2004-12-23 15:16:30 +02:00
}
void cmph_config_set_verbosity(cmph_config_t *mph, cmph_uint32 verbosity)
2004-12-23 15:16:30 +02:00
{
mph->verbosity = verbosity;
}
void cmph_config_set_hashfuncs(cmph_config_t *mph, CMPH_HASH *hashfuncs)
2004-12-23 15:16:30 +02:00
{
switch (mph->algo)
{
2005-01-25 23:06:58 +02:00
case CMPH_CHM:
chm_config_set_hashfuncs(mph, hashfuncs);
2004-12-23 15:16:30 +02:00
break;
2005-01-18 23:06:08 +02:00
case CMPH_BMZ: /* included -- Fabiano */
bmz_config_set_hashfuncs(mph, hashfuncs);
2004-12-23 15:16:30 +02:00
break;
case CMPH_BMZ8: /* included -- Fabiano */
bmz8_config_set_hashfuncs(mph, hashfuncs);
break;
2005-07-28 00:13:02 +03:00
case CMPH_BRZ: /* included -- Fabiano */
brz_config_set_hashfuncs(mph, hashfuncs);
2005-07-28 00:13:02 +03:00
break;
2004-12-23 15:16:30 +02:00
default:
break;
}
return;
}
void cmph_config_set_graphsize(cmph_config_t *mph, float c)
{
mph->c = c;
return;
}
2004-12-23 15:16:30 +02:00
cmph_t *cmph_new(cmph_config_t *mph)
2004-12-23 15:16:30 +02:00
{
cmph_t *mphf = NULL;
float c = mph->c;
DEBUGP("Creating mph with algorithm %s\n", cmph_names[mph->algo]);
2004-12-23 15:16:30 +02:00
switch (mph->algo)
{
2005-01-25 23:06:58 +02:00
case CMPH_CHM:
DEBUGP("Creating chm hash\n");
if (c == 0) c = 2.09;
2005-01-25 23:06:58 +02:00
mphf = chm_new(mph, c);
2004-12-23 15:16:30 +02:00
break;
2005-01-18 23:06:08 +02:00
case CMPH_BMZ: /* included -- Fabiano */
2004-12-23 15:16:30 +02:00
DEBUGP("Creating bmz hash\n");
if (c == 0) c = 1.15;
mphf = bmz_new(mph, c);
2004-12-23 15:16:30 +02:00
break;
case CMPH_BMZ8: /* included -- Fabiano */
DEBUGP("Creating bmz8 hash\n");
if (c == 0) c = 1.15;
mphf = bmz8_new(mph, c);
break;
2005-07-28 00:13:02 +03:00
case CMPH_BRZ: /* included -- Fabiano */
DEBUGP("Creating brz hash\n");
2005-07-28 00:13:02 +03:00
if (c == 0) c = 1.15;
mphf = brz_new(mph, c);
2005-07-28 00:13:02 +03:00
break;
2004-12-23 15:16:30 +02:00
default:
assert(0);
}
return mphf;
}
int cmph_dump(cmph_t *mphf, FILE *f)
2004-12-23 15:16:30 +02:00
{
switch (mphf->algo)
{
2005-01-25 23:06:58 +02:00
case CMPH_CHM:
return chm_dump(mphf, f);
2005-01-18 23:06:08 +02:00
case CMPH_BMZ: /* included -- Fabiano */
return bmz_dump(mphf, f);
case CMPH_BMZ8: /* included -- Fabiano */
return bmz8_dump(mphf, f);
2005-07-28 00:13:02 +03:00
case CMPH_BRZ: /* included -- Fabiano */
return brz_dump(mphf, f);
2004-12-23 15:16:30 +02:00
default:
assert(0);
}
assert(0);
return 0;
}
cmph_t *cmph_load(FILE *f)
2004-12-23 15:16:30 +02:00
{
cmph_t *mphf = NULL;
2004-12-23 15:16:30 +02:00
DEBUGP("Loading mphf generic parts\n");
mphf = __cmph_load(f);
2004-12-23 15:16:30 +02:00
if (mphf == NULL) return NULL;
DEBUGP("Loading mphf algorithm dependent parts\n");
switch (mphf->algo)
{
2005-01-25 23:06:58 +02:00
case CMPH_CHM:
chm_load(f, mphf);
2004-12-23 15:16:30 +02:00
break;
2005-01-18 23:06:08 +02:00
case CMPH_BMZ: /* included -- Fabiano */
DEBUGP("Loading bmz algorithm dependent parts\n");
bmz_load(f, mphf);
2004-12-23 15:16:30 +02:00
break;
case CMPH_BMZ8: /* included -- Fabiano */
DEBUGP("Loading bmz8 algorithm dependent parts\n");
bmz8_load(f, mphf);
break;
2005-07-28 00:13:02 +03:00
case CMPH_BRZ: /* included -- Fabiano */
DEBUGP("Loading brz algorithm dependent parts\n");
brz_load(f, mphf);
2005-07-28 00:13:02 +03:00
break;
2004-12-23 15:16:30 +02:00
default:
assert(0);
}
DEBUGP("Loaded mphf\n");
return mphf;
}
cmph_uint32 cmph_search(cmph_t *mphf, const char *key, cmph_uint32 keylen)
2004-12-23 15:16:30 +02:00
{
DEBUGP("mphf algorithm: %u \n", mphf->algo);
switch(mphf->algo)
{
2005-01-25 23:06:58 +02:00
case CMPH_CHM:
return chm_search(mphf, key, keylen);
2005-01-18 23:06:08 +02:00
case CMPH_BMZ: /* included -- Fabiano */
2004-12-23 15:16:30 +02:00
DEBUGP("bmz algorithm search\n");
return bmz_search(mphf, key, keylen);
case CMPH_BMZ8: /* included -- Fabiano */
DEBUGP("bmz8 algorithm search\n");
return bmz8_search(mphf, key, keylen);
2005-07-28 00:13:02 +03:00
case CMPH_BRZ: /* included -- Fabiano */
DEBUGP("brz algorithm search\n");
return brz_search(mphf, key, keylen);
2004-12-23 15:16:30 +02:00
default:
assert(0);
}
assert(0);
return 0;
2004-12-23 15:16:30 +02:00
}
cmph_uint32 cmph_size(cmph_t *mphf)
2004-12-23 15:16:30 +02:00
{
return mphf->size;
}
void cmph_destroy(cmph_t *mphf)
2004-12-23 15:16:30 +02:00
{
switch(mphf->algo)
{
2005-01-25 23:06:58 +02:00
case CMPH_CHM:
chm_destroy(mphf);
2004-12-23 15:16:30 +02:00
return;
2005-01-18 23:06:08 +02:00
case CMPH_BMZ: /* included -- Fabiano */
bmz_destroy(mphf);
2004-12-23 15:16:30 +02:00
return;
case CMPH_BMZ8: /* included -- Fabiano */
bmz8_destroy(mphf);
return;
2005-07-28 00:13:02 +03:00
case CMPH_BRZ: /* included -- Fabiano */
brz_destroy(mphf);
2005-07-28 00:13:02 +03:00
return;
2004-12-23 15:16:30 +02:00
default:
assert(0);
}
assert(0);
return;
}