src/y_keyvalue.c

   1 /*
   2     gcc -W -Wall -D__KEYVALUE_DEBUG__ -DMALLOC_DEBUG y_keyvalue.c swf_debug.c
   3  */
   4 #include <stdio.h>
   5 #include <stdlib.h>
   6 #include <string.h>
   7 #include "swf_define.h"
   8 #include "y_keyvalue.h"
   9
  10 //#define Y_KEYVALUE_INITSIZE 10
  11 #define Y_KEYVALUE_INITSIZE 1
  12
  13 /*
  14  * open/close
  15  */
  16 y_keyvalue_t *
  17 y_keyvalue_open() {
  18     y_keyvalue_t *st = calloc(sizeof(*st), 1);
  19     if (st == NULL) {
  20         fprintf(stderr, "y_keyvalue_open: calloc failed\n");
  21         return NULL;
  22     }
  23     st->use_len = 0;
  24     st->alloc_len = Y_KEYVALUE_INITSIZE;
  25     st->table = malloc(sizeof(*st->table) * Y_KEYVALUE_INITSIZE);
  26     return st;
  27 }
  28
  29 void
  30 y_keyvalue_close(y_keyvalue_t *st) {
  31     int i;
  32     for (i = 0 ; i < st->use_len ; i++) {
  33         if (st->table[i].use) {
  34             free(st->table[i].key);
  35             free(st->table[i].value);
  36         }
  37     }
  38     free(st->table);
  39     free(st);
  40 }
  41
  42 /*
  43  * set/get/delete
  44  */
  45
  46 int
  47 y_keyvalue_set(y_keyvalue_t *st, char *key, int key_len, char *value, int value_len) {
  48     int i, offset = -1;
  49     void *tmp;
  50     if (st->use_len < st->alloc_len) {
  51         offset = st->use_len;
  52     } else {
  53         for (i = 0 ; i < st->alloc_len ; i++) {
  54             if (st->table[i].use == 0) {
  55                 offset = i;
  56                 break;
  57             }
  58         }
  59         if (offset == -1) {
  60             tmp = realloc(st->table, 2 * st->alloc_len * sizeof(*(st->table)));
  61             if (tmp == NULL) {
  62                 fprintf(stderr, "y_keyvalue_set: realloc failed\n");
  63                 return 1;
  64             }
  65             st->table = tmp;
  66             st->alloc_len = 2 * st->alloc_len;
  67             offset = st->use_len;
  68         }
  69     }
  70     st->table[offset].key = malloc(key_len);
  71     if (st->table[offset].key == NULL) {
  72
  73     }
  74     st->table[offset].value = malloc(value_len);
  75     if (st->table[offset].value == NULL) {
  76         free(st->table[offset].key);
  77         return 1; // NG
  78     }
  79     memcpy(st->table[offset].key, key, key_len);
  80     memcpy(st->table[offset].value, value, value_len);
  81     st->table[offset].key_len = key_len;
  82     st->table[offset].value_len = value_len;
  83     st->table[offset].use = 1;
  84     if (offset == st->use_len) {
  85         st->use_len = offset + 1;
  86     }
  87     return 0;
  88 }
  89
  90 char *
  91 y_keyvalue_get(y_keyvalue_t *st, char *key, int key_len, int *value_len) {
  92     int i;
  93     for (i = 0 ; i < st->use_len ; i++) {
  94         if ((st->table[i].use) &&
  95             (st->table[i].key_len == key_len) &&
  96             (memcmp(st->table[i].key, key, key_len) == 0)) {
  97             *value_len = st->table[i].value_len;
  98             return st->table[i].value;
  99         }
 100     }
 101     return NULL;
 102 }
 103
 104 int
 105 y_keyvalue_delete(y_keyvalue_t *st, char *key, int key_len) {
 106     int i;
 107     for (i = 0 ; i < st->use_len ; i++) {
 108         if ((st->table[i].use) &&
 109             (st->table[i].key_len == key_len) &&
 110             (memcmp(st->table[i].key, key, key_len) == 0)) {
 111             free(st->table[i].key);
 112             free(st->table[i].value);
 113             st->table[i].key = 0;
 114             st->table[i].value = 0;
 115             st->table[i].use = 0;
 116             return 0;
 117         }
 118     }
 119     return 1;
 120 }
 121
 122 /*
 123  * itelator reguler/reverse
 124  */
 125 void
 126 y_keyvalue_rewind(y_keyvalue_t *st) {
 127     for (st->get_offset = 0 ; st->get_offset < st->use_len; st->get_offset++) {
 128         if (st->table[st->get_offset].use) {
 129             break;
 130         }
 131     }
 132 }
 133
 134 void
 135 y_keyvalue_seeklast(y_keyvalue_t *st) {
 136     for (st->get_offset = st->use_len - 1 ; st->get_offset >= 0 ; st->get_offset--) {
 137         if (st->table[st->get_offset].use) {
 138             break;
 139         }
 140     }
 141 }
 142
 143 int
 144 y_keyvalue_next(y_keyvalue_t *st) {
 145     for (st->get_offset++; st->get_offset < st->use_len; st->get_offset++) {
 146         if (st->table[st->get_offset].use) {
 147             return 1; // found
 148         }
 149     }
 150     return 0;// false
 151
 152 }
 153 int
 154 y_keyvalue_prev(y_keyvalue_t *st) {
 155     for (st->get_offset--; st->get_offset >= 0; st->get_offset--) {
 156         if (st->table[st->get_offset].use) {
 157             return 1; // found
 158         }
 159     }
 160     return 0;// false
 161
 162 }
 163
 164 char *
 165 y_keyvalue_get_currentkey(y_keyvalue_t *st, int *key_len) {
 166     if (st->get_offset < 0) {
 167         return NULL;
 168     }
 169     if (st->get_offset >= st->use_len) {
 170         return NULL;
 171     }
 172     *key_len = st->table[st->get_offset].key_len;
 173     return st->table[st->get_offset].key;
 174 }
 175
 176 char *
 177 y_keyvalue_get_currentvalue(y_keyvalue_t *st, int *value_len) {
 178     if (st->get_offset >= st->use_len) {
 179         return NULL;
 180     }
 181     *value_len = st->table[st->get_offset].value_len;
 182     return st->table[st->get_offset].value;
 183 }
 184
 185 int
 186 y_keyvalue_get_maxkeylength(y_keyvalue_t *st) {
 187     int i;
 188     int maxlen = 0;
 189     for (i = 0 ; i < st->use_len ; i++) {
 190         if (st->table[i].use) {
 191             if (maxlen < st->table[i].key_len) {
 192                 maxlen = st->table[i].key_len;
 193             }
 194         }
 195     }
 196     return maxlen;
 197 }
 198
 199 int
 200 y_keyvalue_get_maxvaluelength(y_keyvalue_t *st) {
 201     int i;
 202     int maxlen = 0;
 203     for (i = 0 ; i < st->use_len ; i++) {
 204         if (st->table[i].use) {
 205             if (maxlen < st->table[i].value_len) {
 206                 maxlen = st->table[i].value_len;
 207             }
 208         }
 209     }
 210     return maxlen;
 211 }
 212
 213 int
 214 y_keyvalue_get_maxkeyvaluelength(y_keyvalue_t *st) {
 215     int key_maxlen;
 216     int value_maxlen;
 217     key_maxlen = y_keyvalue_get_maxkeylength(st);
 218     value_maxlen = y_keyvalue_get_maxvaluelength(st);
 219     return (key_maxlen>value_maxlen)?key_maxlen:value_maxlen;
 220 }
 221
 222 void
 223 y_keyvalue_dump(y_keyvalue_t *st) {
 224     int i;
 225     for (i = 0 ; i < st->use_len ; i++) {
 226         printf("[%d] ", i);
 227         if (st->table[i].use) {
 228             printf("key:%.*s", st->table[i].key_len, st->table[i].key);
 229             printf("value:%.*s", st->table[i].value_len, st->table[i].value);
 230             printf("\n");
 231         } else {
 232             printf("deleted");
 233             printf("\n");
 234         }
 235     }
 236 }
 237
 238 #ifdef __KEYVALUE_DEBUG__
 239
 240 int main(void) {
 241     char *key, *value;
 242     int key_len, value_len;
 243     malloc_debug_start();
 244     y_keyvalue_t *st = y_keyvalue_open();
 245     y_keyvalue_set(st, "foo", 4, "baa", 4);
 246     y_keyvalue_set(st, "baz", 4, "buz", 4);
 247     printf("reguler iterate test\n");
 248     y_keyvalue_rewind(st);
 249     while (key = y_keyvalue_get_currentkey(st, &key_len)) {
 250
 251         value = y_keyvalue_get_currentvalue(st, &value_len);
 252         printf("key=%s(%d), value=%s(%d)\n", key, key_len, value, value_len);
 253         if (y_keyvalue_next(st) == 0) {
 254             break;
 255         }
 256     }
 257     printf("reverse iterate test\n");
 258     y_keyvalue_seeklast(st);
 259     while (key = y_keyvalue_get_currentkey(st, &key_len)) {
 260
 261         value = y_keyvalue_get_currentvalue(st, &value_len);
 262         printf("key=%s(%d), value=%s(%d)\n", key, key_len, value, value_len);
 263         if (y_keyvalue_prev(st) == 0) {
 264             break;
 265         }
 266     }
 267     printf("delete test\n");
 268     y_keyvalue_delete(st, "foo", 4);
 269     y_keyvalue_rewind(st);
 270     while (key = y_keyvalue_get_currentkey(st, &key_len)) {
 271         value = y_keyvalue_get_currentvalue(st, &value_len);
 272         printf("key=%s(%d), value=%s(%d)\n", key, key_len, value, value_len);
 273         if (y_keyvalue_next(st) == 0) {
 274             break;
 275         }
 276     }
 277     y_keyvalue_close(st);
 278     malloc_debug_end();
 279     return 0;
 280 }
 281
 282 #endif /* __KEYVALUE_DEBUG__ */