git.m6w6.name Git - awesomized/libmemcached/blob - libmemcached/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() : memc(), result()
  17   {
  18     memcached_create(&memc);
  19   }
  20
  21   Memcached(memcached_st *clone) : memc(), result()
  22   {
  23     memcached_clone(&memc, clone);
  24   }
  25   char *fetch (char *key, size_t *key_length, size_t *value_length)
  26   {
  27     uint32_t flags;
  28     memcached_return rc;
  29
  30     return memcached_fetch(&memc, key, key_length,
  31                     value_length, &flags, &rc);
  32   }
  33   char *get(const char *key, size_t *value_length)
  34   {
  35     uint32_t flags;
  36     memcached_return rc;
  37
  38     return memcached_get(&memc, key, strlen(key),
  39                          value_length, &flags, &rc);
  40   }
  41
  42   char *get_by_key(const char *master_key, const char *key,
  43                    size_t *value_length)
  44   {
  45     uint32_t flags;
  46     memcached_return rc;
  47
  48     return memcached_get_by_key(&memc, master_key, strlen(master_key),
  49                                 key, strlen(key),
  50                                 value_length, &flags, &rc);
  51   }
  52
  53   memcached_return mget(char **keys, size_t *key_length,
  54                         unsigned int number_of_keys)
  55   {
  56
  57     return memcached_mget(&memc, keys, key_length, number_of_keys);
  58   }
  59
  60   memcached_return set(const char *key, const char *value, size_t value_length)
  61   {
  62     return memcached_set(&memc, key, strlen(key),
  63                          value, value_length,
  64                          time_t(0), uint32_t(0));
  65   }
  66
  67   memcached_return set_by_key(const char *master_key, const char *key,
  68                               const char *value, size_t value_length)
  69   {
  70     return memcached_set_by_key(&memc, master_key, strlen(master_key),
  71                          key, strlen(key),
  72                          value, value_length,
  73                          time_t(0),
  74                          uint32_t(0) );
  75   }
  76   memcached_return
  77     increment(const char *key, unsigned int offset, uint64_t *value)
  78   {
  79     return memcached_increment(&memc, key, strlen(key),
  80                          offset, value);
  81   }
  82   memcached_return
  83     decrement(const char *key, unsigned int offset, uint64_t *value)
  84   {
  85     return memcached_decrement(&memc, key, strlen(key),
  86                          offset, value);
  87   }
  88
  89
  90   memcached_return add(const char *key, const char *value, size_t value_length)
  91   {
  92     return memcached_add(&memc, key, strlen(key), value, value_length, 0, 0);
  93   }
  94   memcached_return add_by_key(const char *master_key, const char *key,
  95                               const char *value, size_t value_length)
  96   {
  97     return memcached_add_by_key(&memc, master_key, strlen(master_key),
  98                                 key, strlen(key),
  99                                 value, value_length,
 100                                 0, 0);
 101   }
 102
 103   memcached_return replace(const char *key, const char *value,
 104                            size_t value_length)
 105   {
 106     return memcached_replace(&memc, key, strlen(key),
 107                      value, value_length,
 108                      0, 0);
 109   }
 110   memcached_return replace_by_key(const char *master_key, const char *key,
 111                                   const char *value, size_t value_length)
 112   {
 113     return memcached_replace_by_key(&memc, master_key, strlen(master_key),
 114                                     key, strlen(key),
 115                                     value, value_length, 0, 0);
 116   }
 117
 118   memcached_return prepend(const char *key, const char *value,
 119                            size_t value_length)
 120   {
 121     return memcached_prepend(&memc, key, strlen(key),
 122                     value, value_length, 0, 0);
 123   }
 124   memcached_return prepend_by_key(const char *master_key, const char *key,
 125                                   const char *value, size_t value_length)
 126   {
 127     return memcached_prepend_by_key(&memc, master_key, strlen(master_key),
 128                                     key, strlen(key),
 129                                     value, value_length,
 130                                     0,
 131                                     0);
 132   }
 133
 134   memcached_return  append(const char *key, const char *value,
 135                            size_t value_length)
 136   {
 137     return memcached_append(&memc, key, strlen(key),
 138                     value, value_length, 0, 0);
 139   }
 140   memcached_return  append_by_key(const char *master_key, const char *key,
 141                                   const char *value, size_t value_length)
 142   {
 143     return memcached_append_by_key(&memc,
 144                                    master_key, strlen(master_key),
 145                                    key, strlen(key),
 146                                    value, value_length, 0, 0);
 147   }
 148   memcached_return  cas(const char *key, const char *value,
 149                         size_t value_length, uint64_t cas)
 150   {
 151     return memcached_cas(&memc, key, strlen(key),
 152                     value, value_length, 0, 0, cas);
 153   }
 154   memcached_return  cas_by_key(const char *master_key, const char *key,
 155                                const char *value, size_t value_length,
 156                                uint64_t cas)
 157   {
 158     return memcached_cas_by_key(&memc,
 159                                 master_key, strlen(master_key),
 160                                 key, strlen(key),
 161                                 value, value_length,
 162                                 0, 0, cas);
 163   }
 164   // using 'remove' vs. 'delete' since 'delete' is a keyword
 165   memcached_return remove(const char *key)
 166   {
 167     return memcached_delete (&memc, key, strlen(key), 0);
 168
 169   }
 170   memcached_return delete_by_key(const char *master_key, const char *key)
 171   {
 172     return memcached_delete_by_key(&memc, master_key, strlen(master_key),
 173                            key, strlen(key), 0);
 174   }
 175   ~Memcached()
 176   {
 177     memcached_free(&memc);
 178   }
 179 };