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

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