← Back to branch summary

~ubuntu-branches/ubuntu/trusty/rhash/trusty

« back to all changes in this revision

Viewing changes to librhash/util.h

  • Committer: Bazaar Package Importer
  • Author(s): Alexey S Kravchenko
  • Date: 2011-06-15 01:03:34 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20110615010334-ochayini7ut2djvs
Tags: 1.2.6-1
* New upstream release version 1.2.6
 - ABI changed - now librhash0.0 is librhash0
 - OpenSSL support for faster hash calculation if libssl is installed
   (fully optional) for both rhash and librhash0

Show diffs side-by-side

added added

removed removed

Lines of Context:
librhash/util.h
15
15
void* rhash_realloc(void* mem, size_t size, const char* srcfile, int srcline);
16
16
 
17
17
extern void (*rsh_exit)(int code);
18
 
extern void (*report_error)(const char* srcfile, int srcline, const char* format, ...);
 
18
extern void (*rsh_report_error)(const char* srcfile, int srcline, const char* format, ...);
19
19
 
20
20
/* vector functions */
21
21
typedef struct vector_t
22
22
{
23
 
  void **array;
24
 
  size_t size;
25
 
  size_t allocated;
26
 
  void (*destructor)(void*);
 
23
        void **array;
 
24
        size_t size;
 
25
        size_t allocated;
 
26
        void (*destructor)(void*);
27
27
} vector_t;
28
28
 
29
 
struct vector_t* vector_new(void (*destructor)(void*));
30
 
struct vector_t* vector_new_simple(void);
31
 
void vector_free(struct vector_t* vect);
32
 
void vector_destroy(struct vector_t* vect);
33
 
void vector_add_ptr (struct vector_t* vect, void *item);
34
 
void vector_sort(struct vector_t* vect, int (*compare)(const void *rec1, const void *rec2));
35
 
void vector_item_add_empty(struct vector_t* vect, size_t item_size);
36
 
#define vector_add_uint32(vect, item) { \
37
 
  vector_item_add_empty(vect, item_size); \
38
 
  ((unsigned*)(vect)->array)[(vect)->size - 1] = item; \
 
29
struct vector_t* rsh_vector_new(void (*destructor)(void*));
 
30
struct vector_t* rsh_vector_new_simple(void);
 
31
void rsh_vector_free(struct vector_t* vect);
 
32
void rsh_vector_destroy(struct vector_t* vect);
 
33
void rsh_vector_add_ptr(struct vector_t* vect, void *item);
 
34
/*void rsh_vector_sort(struct vector_t* vect, int (*compare)(const void *rec1, const void *rec2));*/
 
35
void rsh_vector_item_add_empty(struct vector_t* vect, size_t item_size);
 
36
#define rsh_vector_add_uint32(vect, item) { \
 
37
        rsh_vector_item_add_empty(vect, item_size); \
 
38
        ((unsigned*)(vect)->array)[(vect)->size - 1] = item; \
39
39
}
40
 
#define vector_add_item(vect, item, item_size) { \
41
 
  vector_item_add_empty(vect, item_size); \
42
 
  memcpy(((char*)(vect)->array) + item_size * ((vect)->size - 1), item, item_size); \
 
40
#define rsh_vector_add_item(vect, item, item_size) { \
 
41
        rsh_vector_item_add_empty(vect, item_size); \
 
42
        memcpy(((char*)(vect)->array) + item_size * ((vect)->size - 1), item, item_size); \
43
43
}
44
44
 
45
45
/* a vector pattern implementation, allocating elements by blocks */
46
46
typedef struct blocks_vector_t
47
47
{
48
 
  size_t size;
49
 
  vector_t blocks;
 
48
        size_t size;
 
49
        vector_t blocks;
50
50
} blocks_vector_t;
51
51
 
52
 
void blocks_vector_init(struct blocks_vector_t*);
53
 
/* #define blocks_vector_init(bvector) memset(bvector, 0, sizeof(*bvector)); */
54
 
void blocks_vector_destroy(struct blocks_vector_t* vect);
55
 
#define blocks_vector_get_item(bvector, index, blocksize, item_type) \
56
 
  (&((item_type*)((bvector)->blocks.array[index / blocksize]))[index % blocksize])
57
 
#define blocks_vector_get_ptr(bvector, index, blocksize, item_size) \
58
 
  (&((unsigned char*)((bvector)->blocks.array[index / blocksize]))[item_size * (index % blocksize)])
59
 
#define blocks_vector_add(bvector, item, blocksize, item_size) { \
60
 
  if(((bvector)->size % blocksize) == 0) \
61
 
    vector_add_ptr(&((bvector)->blocks), rsh_malloc(item_size * blocksize)); \
62
 
  memcpy(blocks_vector_get_ptr((bvector), (bvector)->size, blocksize, item_size), (item), item_size); \
63
 
  (bvector)->size++; \
64
 
}
65
 
#define blocks_vector_add_empty(bvector, blocksize, item_size) { \
66
 
  if( (((bvector)->size++) % blocksize) == 0) \
67
 
    vector_add_ptr(&((bvector)->blocks), rsh_malloc(item_size * blocksize)); \
 
52
void rsh_blocks_vector_init(struct blocks_vector_t*);
 
53
/* #define rsh_blocks_vector_init(bvector) memset(bvector, 0, sizeof(*bvector)); */
 
54
void rsh_blocks_vector_destroy(struct blocks_vector_t* vect);
 
55
#define rsh_blocks_vector_get_item(bvector, index, blocksize, item_type) \
 
56
        (&((item_type*)((bvector)->blocks.array[(index) / (blocksize)]))[(index) % (blocksize)])
 
57
#define rsh_blocks_vector_get_ptr(bvector, index, blocksize, item_size) \
 
58
        (&((unsigned char*)((bvector)->blocks.array[(index) / (blocksize)]))[(item_size) * ((index) % (blocksize))])
 
59
#define rsh_blocks_vector_add(bvector, item, blocksize, item_size) { \
 
60
        if(((bvector)->size % (blocksize)) == 0) \
 
61
                rsh_vector_add_ptr(&((bvector)->blocks), rsh_malloc((item_size) * (blocksize))); \
 
62
        memcpy(rsh_blocks_vector_get_ptr((bvector), (bvector)->size, (blocksize), (item_size)), (item), (item_size)); \
 
63
        (bvector)->size++; \
 
64
}
 
65
#define rsh_blocks_vector_add_ptr(bvector, ptr, blocksize) { \
 
66
        if(((bvector)->size % (blocksize)) == 0) \
 
67
                rsh_vector_add_ptr(&((bvector)->blocks), rsh_malloc(sizeof(void*) * (blocksize))); \
 
68
        ((void***)(bvector)->blocks.array)[(bvector)->size / (blocksize)][(bvector)->size % (blocksize)] = (void*)ptr; \
 
69
        (bvector)->size++; \
 
70
}
 
71
#define rsh_blocks_vector_add_empty(bvector, blocksize, item_size) { \
 
72
        if( (((bvector)->size++) % (blocksize)) == 0) \
 
73
                rsh_vector_add_ptr(&((bvector)->blocks), rsh_malloc((item_size) * (blocksize))); \
68
74
}
69
75
 
70
76
/* string buffer functions */
71
77
typedef struct strbuf_t
72
78
{
73
 
  char* str;
74
 
  size_t allocated;
75
 
  size_t len;
 
79
        char* str;
 
80
        size_t allocated;
 
81
        size_t len;
76
82
} strbuf_t;
77
83
 
78
 
strbuf_t* str_new(void);
79
 
void str_free(strbuf_t* buf);
80
 
void strbuf_ensure_size(strbuf_t *str, size_t new_size);
81
 
void str_append_n(strbuf_t *str, const char* text, size_t len);
82
 
void str_append(strbuf_t *str, const char* text);
 
84
strbuf_t* rsh_str_new(void);
 
85
void rsh_str_free(strbuf_t* buf);
 
86
void rsh_str_ensure_size(strbuf_t *str, size_t new_size);
 
87
void rsh_str_append_n(strbuf_t *str, const char* text, size_t len);
 
88
void rsh_str_append(strbuf_t *str, const char* text);
83
89
 
84
 
#define str_ensure_size(str, len) \
85
 
  if((size_t)(len) >= (size_t)(str)->allocated) strbuf_ensure_size((str), (len) + 1);
86
 
#define wstr_ensure_size(str, len) \
87
 
  if((size_t)((len) + 2) > (size_t)(str)->allocated) strbuf_ensure_size((str), (len) + 2);
 
90
#define rsh_str_ensure_length(str, len) \
 
91
        if((size_t)(len) >= (size_t)(str)->allocated) rsh_str_ensure_size((str), (len) + 1);
 
92
#define rsh_wstr_ensure_length(str, len) \
 
93
        if((size_t)((len) + 2) > (size_t)(str)->allocated) rsh_str_ensure_size((str), (len) + 2);
88
94
 
89
95
#ifdef __cplusplus
90
96
} /* extern "C" */