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

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