git.m6w6.name Git - m6w6/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, size_t value_length)
 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, const std::string& key,
 132                   const std::string& value, size_t value_length)
 133   {
 134     memcached_return rc= memcached_add_by_key(&memc,
 135                                               master_key.c_str(),
 136                                               master_key.length(),
 137                                               key.c_str(),
 138                                               key.length(),
 139                                               value.c_str(),
 140                                               value_length,
 141                                               0, 0);
 142     return (rc == MEMCACHED_SUCCESS);
 143   }
 144
 145   bool replace(const std::string& key, const std::string& value,
 146                size_t value_length)
 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, const std::string& key,
 155                       const std::string& value, size_t value_length)
 156   {
 157     memcached_return rc= memcached_replace_by_key(&memc,
 158                                                   master_key.c_str(),
 159                                                   master_key.length(),
 160                                                   key.c_str(),
 161                                                   key.length(),
 162                                                   value.c_str(),
 163                                                   value_length,
 164                                                   0, 0);
 165     return (rc == MEMCACHED_SUCCESS);
 166   }
 167
 168   bool prepend(const std::string& key, const std::string& value,
 169                size_t value_length)
 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, const std::string& key,
 177                       const std::string& value, size_t value_length)
 178   {
 179     memcached_return rc= memcached_prepend_by_key(&memc,
 180                                                   master_key.c_str(),
 181                                                   master_key.length(),
 182                                                   key.c_str(),
 183                                                   key.length(),
 184                                                   value.c_str(),
 185                                                   value_length,
 186                                                   0,
 187                                                   0);
 188     return (rc == MEMCACHED_SUCCESS);
 189   }
 190
 191   bool append(const std::string& key, const std::string& value,
 192               size_t value_length)
 193   {
 194     memcached_return rc= memcached_append(&memc,
 195                                           key.c_str(),
 196                                           key.length(),
 197                                           value.c_str(),
 198                                           value_length, 0, 0);
 199     return (rc == MEMCACHED_SUCCESS);
 200   }
 201
 202   bool append_by_key(const std::string& master_key, const std::string& key,
 203                      const std::string& value, size_t value_length)
 204   {
 205     memcached_return rc= memcached_append_by_key(&memc,
 206                                                  master_key.c_str(),
 207                                                  master_key.length(),
 208                                                  key.c_str(),
 209                                                  key.length(),
 210                                                  value.c_str(),
 211                                                  value_length, 0, 0);
 212     return (rc == MEMCACHED_SUCCESS);
 213   }
 214
 215   bool cas(const std::string& key, const std::string& value,
 216            size_t value_length, uint64_t cas_arg)
 217   {
 218     memcached_return rc= memcached_cas(&memc, key.c_str(), key.length(),
 219                                        value.c_str(), value_length, 0, 0, cas_arg);
 220     return (rc == MEMCACHED_SUCCESS);
 221   }
 222
 223   bool cas_by_key(const std::string& master_key, const std::string& key,
 224                   const std::string& value, size_t value_length,
 225                   uint64_t cas_arg)
 226   {
 227     memcached_return rc= memcached_cas_by_key(&memc,
 228                                               master_key.c_str(),
 229                                               master_key.length(),
 230                                               key.c_str(),
 231                                               key.length(),
 232                                               value.c_str(),
 233                                               value_length,
 234                                               0, 0, cas_arg);
 235     return (rc == MEMCACHED_SUCCESS);
 236   }
 237
 238   // using 'remove' vs. 'delete' since 'delete' is a keyword
 239   bool remove(const std::string& key)
 240   {
 241     memcached_return rc= memcached_delete(&memc, key.c_str(), key.length(), 0);
 242     return (rc == MEMCACHED_SUCCESS);
 243   }
 244
 245   bool delete_by_key(const std::string& master_key,
 246                      const std::string& key)
 247   {
 248     memcached_return rc= memcached_delete_by_key(&memc,
 249                                                  master_key.c_str(),
 250                                                  master_key.length(),
 251                                                  key.c_str(),
 252                                                  key.length(),
 253                                                  0);
 254     return (rc == MEMCACHED_SUCCESS);
 255   }
 256
 257   const std::string lib_version() const
 258   {
 259     const char *ver= memcached_lib_version();
 260     const std::string version(ver);
 261     return version;
 262   }
 263
 264 private:
 265   memcached_st memc;
 266   memcached_result_st result;
 267 };