git.m6w6.name Git - awesomized/libmemcached/blob - include/memcached.hh

   1 #ifdef USE_PRAGMA_INTERFACE
   2 #pragma interface                       /* gcc class implementation */
   3 #endif
   4
   5 #include <memcached.h>
   6 #include <string.h>
   7 #include <stdio.h>
   8
   9 class Memcached
  10 {
  11   memcached_st memc;
  12   memcached_result_st result;
  13
  14 public:
  15
  16   Memcached()
  17   {
  18     memcached_create(&memc);
  19   }
  20
  21   Memcached(memcached_st *clone)
  22   {
  23     WATCHPOINT;
  24     memcached_clone(&memc, clone);
  25     WATCHPOINT;
  26   }
  27   memcached_result_st *fetch_result()
  28   {
  29     memcached_return rc;
  30     return memcached_fetch_result(&memc, &result, &rc);
  31   }
  32   /*
  33
  34   memcached_return fetch_execute(
  35             memcached_return ((*callback[]))(&memc,
  36                                              &result,
  37                                              void *context,
  38                                              unsigned in number_of_callbacks))
  39   {
  40     return memcached_fetch_execute(&memc,
  41                             (*callback[])(&memc, &result, context,
  42                                           number_of_callbacks));
  43   }
  44                                         */
  45   char *fetch (char *key, size_t *key_length, size_t *value_length)
  46   {
  47     uint32_t flags;
  48     memcached_return rc;
  49
  50     return memcached_fetch(&memc, key, key_length,
  51                     value_length, &flags, &rc);
  52   }
  53   char *get(char *key, size_t *value_length)
  54   {
  55     uint32_t flags;
  56     memcached_return rc;
  57
  58     return memcached_get(&memc, key, strlen(key),
  59                          value_length, &flags, &rc);
  60   }
  61
  62   char *get_by_key(char *master_key, char *key, size_t *value_length)
  63   {
  64     uint32_t flags;
  65     memcached_return rc;
  66
  67     return memcached_get_by_key(&memc, master_key, strlen(master_key), key, strlen(key),
  68                                 value_length, &flags, &rc);
  69   }
  70
  71   memcached_return mget(char **keys, size_t *key_length, unsigned int number_of_keys)
  72   {
  73
  74     return memcached_mget(&memc, keys, key_length, number_of_keys);
  75   }
  76
  77   memcached_return set(char *key, char *value, size_t value_length)
  78   {
  79     return memcached_set(&memc, key, strlen(key),
  80                          value, value_length,
  81                          (time_t)0, (uint32_t)0);
  82   }
  83
  84   memcached_return set_by_key(char *master_key, char *key, char *value, size_t value_length)
  85   {
  86     return memcached_set_by_key(&memc, master_key, strlen(master_key),
  87                          key, strlen(key),
  88                          value, value_length,
  89                          (time_t)0,
  90                          (uint32_t)0 );
  91   }
  92   memcached_return
  93     increment(char *key, unsigned int offset, uint64_t *value)
  94   {
  95     return memcached_increment(&memc, key, strlen(key),
  96                          offset, value);
  97   }
  98   memcached_return
  99     decrement(char *key, unsigned int offset, uint64_t *value)
 100   {
 101     return memcached_decrement(&memc, key, strlen(key),
 102                          offset, value);
 103   }
 104
 105
 106   memcached_return add(char *key, char *value, size_t value_length)
 107   {
 108     return memcached_add(&memc, key, strlen(key),
 109                  value, value_length,
 110                  (time_t)0, (uint32_t)0);
 111   }
 112   memcached_return add_by_key(char *master_key, char *key, char *value, size_t value_length)
 113   {
 114     return memcached_add_by_key(&memc, master_key, strlen(master_key),
 115                                 key, strlen(key),
 116                                 value, value_length,
 117                                 (time_t)0, (uint32_t)0);
 118   }
 119
 120   memcached_return replace(char *key, char *value, size_t value_length)
 121   {
 122     return memcached_replace(&memc, key, strlen(key),
 123                      value, value_length,
 124                      (time_t)0, (uint32_t)0);
 125   }
 126   memcached_return replace_by_key(char *master_key,
 127                                   char *key, char *value, size_t value_length)
 128   {
 129     return memcached_replace_by_key(&memc, master_key, strlen(master_key),
 130                                     key, strlen(key),
 131                                     value, value_length,
 132                                     (time_t)0, (uint32_t)0);
 133   }
 134
 135   memcached_return prepend(char *key, char *value, size_t value_length)
 136   {
 137     return memcached_prepend(&memc, key, strlen(key),
 138                     value, value_length,
 139                     (time_t)0,
 140                     (uint32_t)0);
 141   }
 142   memcached_return prepend_by_key(char *master_key,
 143                                   char *key, char *value, size_t value_length)
 144   {
 145     return memcached_prepend_by_key(&memc, master_key, strlen(master_key),
 146                                     key, strlen(key),
 147                                     value, value_length,
 148                                     (time_t)0,
 149                                     (uint32_t)0);
 150   }
 151
 152   memcached_return  append(char *key, char *value, size_t value_length)
 153   {
 154     return memcached_append(&memc, key, strlen(key),
 155                     value, value_length,
 156                     (time_t)0,
 157                     (uint32_t)0);
 158   }
 159   memcached_return  append_by_key(char *master_key,
 160                                   char *key, char *value, size_t value_length)
 161   {
 162     return memcached_append_by_key(&memc,
 163                                    master_key, strlen(master_key),
 164                                    key, strlen(key),
 165                                    value, value_length,
 166                                    (time_t)0,
 167                                    (uint32_t)0);
 168   }
 169   memcached_return  cas(char *key, char *value, size_t value_length, uint64_t cas)
 170   {
 171     return memcached_cas(&memc, key, strlen(key),
 172                     value, value_length,
 173                     (time_t)0,
 174                     (uint32_t)0,
 175                     cas);
 176   }
 177   memcached_return  cas_by_key(char *master_key, char *key, char *value,
 178                                size_t value_length, uint64_t cas)
 179   {
 180     return memcached_cas_by_key(&memc,
 181                                 master_key, strlen(master_key),
 182                                 key, strlen(key),
 183                                 value, value_length,
 184                                 (time_t)0,
 185                                 (uint32_t)0,
 186                                 cas);
 187   }
 188   // Ok, so how do I have a 'delete' method, delete being a keyword?
 189   memcached_return delete(char *key)
 190   {
 191     return memcached_delete (&memc, key, strlen(key), (time_t)0);
 192
 193   }
 194   memcached_return delete_by_key(char *master_key, char *key)
 195   {
 196     return memcached_delete_by_key(&memc, master_key, strlen(master_key),
 197                            key, strlen(key), (time_t)0);
 198   }
 199  ~Memcached()
 200  {
 201    memcached_free(&memc);
 202  }
 203 };