src/lib/ecore_config/ecore_config_db.c

   1 /*
   2  * vim:ts=8:sw=3:sts=8:noexpandtab:cino=>5n-3f0^-2{2
   3  */
   4
   5 #ifdef HAVE_CONFIG_H
   6 # include <config.h>
   7 #endif
   8
   9 #include <stdlib.h>
  10 #include <stdio.h>
  11 #include <string.h>
  12 #include <limits.h>
  13
  14 #include <sys/param.h>
  15 #include <sys/types.h>
  16 #include <sys/stat.h>
  17 #include <unistd.h>
  18 #include <locale.h>
  19
  20 #include <Eet.h>
  21
  22 #include "Ecore_Config.h"
  23 #include "ecore_config_private.h"
  24 #include "ecore_config_util.h"
  25
  26 struct _Ecore_Config_DB_File
  27 {
  28    Eet_File *ef;
  29 };
  30
  31 Ecore_Config_DB_File *
  32 _ecore_config_db_open_read(const char *file)
  33 {
  34    Eet_File *ef;
  35    Ecore_Config_DB_File *db;
  36
  37    eet_init();
  38    db = malloc(sizeof(Ecore_Config_DB_File));
  39    if (!db) return NULL;
  40    ef = eet_open((char*)file, EET_FILE_MODE_READ);
  41    if (!ef)
  42      {
  43         free(db);
  44         return NULL;
  45      }
  46    db->ef = ef;
  47    return db;
  48 }
  49
  50 Ecore_Config_DB_File *
  51 _ecore_config_db_open_write(const char *file)
  52 {
  53    Eet_File *ef;
  54    Ecore_Config_DB_File *db;
  55
  56    eet_init();
  57    db = malloc(sizeof(Ecore_Config_DB_File));
  58    if (!db) return NULL;
  59    ef = eet_open((char*)file, EET_FILE_MODE_WRITE);
  60    if (!ef)
  61      {
  62         free(db);
  63         return NULL;
  64      }
  65    db->ef = ef;
  66    return db;
  67 }
  68
  69 void
  70 _ecore_config_db_close(Ecore_Config_DB_File *db)
  71 {
  72    eet_close(db->ef);
  73    free(db);
  74    eet_shutdown();
  75 }
  76
  77 char **
  78 _ecore_config_db_keys_get(Ecore_Config_DB_File *db, int *num_ret)
  79 {
  80    char **keys;
  81    int key_count;
  82    int i;
  83
  84    keys = eet_list(db->ef, (char*)"*", &key_count);
  85    if (!keys)
  86      {
  87         *num_ret = 0;
  88         return NULL;
  89      }
  90    /* make keys freeable - this is safe to do */
  91    for (i = 0; i < key_count; i++) keys[i] = strdup(keys[i]);
  92    *num_ret = key_count;
  93    return keys;
  94 }
  95
  96 Ecore_Config_Type
  97 _ecore_config_db_key_type_get(Ecore_Config_DB_File *db, const char *key)
  98 {
  99    char *data;
 100    int size;
 101
 102    data = eet_read(db->ef, (char*)key, &size);
 103    if (data)
 104      {
 105         if (size <= 2)
 106           {
 107              free(data);
 108              return ECORE_CONFIG_NIL;
 109           }
 110         if (data[size - 1] != 0)
 111           {
 112              free(data);
 113              return ECORE_CONFIG_NIL;
 114           }
 115         return (Ecore_Config_Type) data[0];
 116      }
 117    return ECORE_CONFIG_NIL;
 118 }
 119
 120 int
 121 _ecore_config_db_read(Ecore_Config_DB_File *db, const char *key)
 122 {
 123    char *data, *value;
 124    int size;
 125    Ecore_Config_Type type;
 126
 127    data = eet_read(db->ef, (char*)key, &size);
 128    if (data)
 129      {
 130         int l;
 131         char *prev_locale;
 132
 133         if (size <= 2)
 134           {
 135              free(data);
 136              return 0;
 137           }
 138         if (data[size - 1] != 0)
 139           {
 140              free(data);
 141              return 0;
 142           }
 143         /* "type" NIL 1242 NIL */
 144         l = strlen(data);
 145         if (l >= (size - 1))
 146           {
 147              free(data);
 148              return 0;
 149           }
 150
 151         type = data[0];
 152         value = data + l + 1;
 153
 154         switch (type)
 155           {
 156              case ECORE_CONFIG_INT:
 157              case ECORE_CONFIG_BLN:
 158                {
 159                   int tmp;
 160                   prev_locale = setlocale(LC_NUMERIC, "C");
 161                   tmp = atoi(value);
 162                   if (prev_locale) setlocale(LC_NUMERIC, prev_locale);
 163
 164                   ecore_config_typed_set(key, (void *)&tmp, type);
 165                   break;
 166                }
 167              case ECORE_CONFIG_FLT:
 168                {
 169                   float tmp;
 170                   prev_locale = setlocale(LC_NUMERIC, "C");
 171                   tmp = atof(value);
 172                   if (prev_locale) setlocale(LC_NUMERIC, prev_locale);
 173
 174                   ecore_config_typed_set(key, (void *)&tmp, type);
 175                   break;
 176                }
 177              case ECORE_CONFIG_RGB:
 178                ecore_config_argbstr_set(key, value);
 179                break;
 180              case ECORE_CONFIG_STR:
 181              case ECORE_CONFIG_THM:
 182                ecore_config_typed_set(key, (void *)value, type);
 183                break;
 184              case ECORE_CONFIG_SCT:
 185                INF("loading struct %s", key);
 186                break;
 187              default:
 188                WRN("Type %d not handled", type);
 189           }
 190         free(data);
 191         return 1;
 192      }
 193    return 0;
 194 }
 195
 196 /*
 197 void *
 198 _ecore_config_db_key_data_get(Ecore_Config_DB_File *db, const char *key, int *size_ret)
 199 {
 200    char *data;
 201    int size;
 202
 203    data = eet_read(db->ef, (char*)key, &size);
 204    if (data)
 205      {
 206         int l;
 207         char *dat;
 208
 209         if (size <= 2)
 210           {
 211              free(data);
 212              return NULL;
 213           }
 214         if (data[size - 1] != 0)
 215           {
 216              free(data);
 217              return NULL;
 218           }
 219         * "type" NIL data_goes_here NIL *
 220         l = strlen(data);
 221         if (l >= (size - 1))
 222           {
 223              free(data);
 224              return NULL;
 225           }
 226         dat = malloc(size - (l + 2));
 227         memcpy(dat, data + l + 1, size - (l + 2));
 228         free(data);
 229         *size_ret = size - (l + 2);
 230         return dat;
 231      }
 232    return NULL;
 233 }*/
 234
 235 void
 236 _ecore_config_db_write(Ecore_Config_DB_File *db, Ecore_Config_Prop *e)
 237 {
 238    char *prev_locale= NULL;
 239    char *val = NULL;
 240    char *r = NULL;
 241    int num;
 242
 243    prev_locale = setlocale(LC_NUMERIC, "C");
 244
 245    switch (e->type)
 246      {
 247         case ECORE_CONFIG_INT:
 248            esprintf(&val, "%i", _ecore_config_int_get(e));
 249            break;
 250         case ECORE_CONFIG_BLN:
 251            esprintf(&val, "%i", _ecore_config_boolean_get(e));
 252            break;
 253         case ECORE_CONFIG_FLT:
 254            esprintf(&val, "%16.16f", _ecore_config_float_get(e));
 255            break;
 256         case ECORE_CONFIG_STR:
 257            val = _ecore_config_string_get(e);
 258            break;
 259         case ECORE_CONFIG_THM:
 260            val = _ecore_config_theme_get(e);
 261            break;
 262         case ECORE_CONFIG_RGB:
 263            val = _ecore_config_argbstr_get(e);
 264            break;
 265         default:
 266            WRN("Type %d not handled", e->type);
 267      }
 268
 269    if (prev_locale)
 270      {
 271         setlocale(LC_NUMERIC, prev_locale);
 272      }
 273
 274    if(val)
 275      {
 276         num = esprintf(&r, "%c%c%s%c", (char) e->type, 0, val, 0);
 277         if(num)
 278           eet_write(db->ef, e->key, r, num, 1);
 279         free(r);
 280      }
 281
 282    free(val);
 283 }
 284 /*
 285 void
 286 _ecore_config_db_key_data_set(Ecore_Config_DB_File *db, const char *key, void *data, int data_size)
 287 {
 288    char *buf;
 289    int num;
 290
 291    num = 1 + 1 + data_size + 1;
 292    buf = malloc(num);
 293    if (!buf) return;
 294    buf[0] = (char) ECORE_CONFIG_BIN;
 295    buf[1] = 0;
 296    memcpy(buf + 2, data, data_size);
 297    buf[num - 1] = 0;
 298    eet_write(db->ef, (char*)key, buf, num, 1);
 299    free(buf);
 300 }*/