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

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