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 char *value, size_t value_length)
  87   {
  88     memcached_return rc= memcached_set(&memc, key.c_str(), key.length(),
  89                                        value, value_length,
  90                                        time_t(0), uint32_t(0));
  91     return (rc == MEMCACHED_SUCCESS);
  92   }
  93
  94   bool set_by_key(const std::string& master_key,
  95                   const std::string& key,
  96                   const char *value, size_t value_length)
  97   {
  98     memcached_return rc= memcached_set_by_key(&memc, master_key.c_str(),
  99                                               master_key.length(),
 100                                               key.c_str(), key.length(),
 101                                               value, value_length,
 102                                               time_t(0),
 103                                               uint32_t(0));
 104     return (rc == MEMCACHED_SUCCESS);
 105   }
 106
 107   bool increment(const std::string& key, unsigned int offset, uint64_t *value)
 108   {
 109     memcached_return rc= memcached_increment(&memc, key.c_str(), key.length(),
 110                                              offset, value);
 111     return (rc == MEMCACHED_SUCCESS);
 112   }
 113
 114   bool decrement(const std::string& key, unsigned int offset, uint64_t *value)
 115   {
 116     memcached_return rc= memcached_decrement(&memc, key.c_str(),
 117                                              key.length(),
 118                                              offset, value);
 119     return (rc == MEMCACHED_SUCCESS);
 120   }
 121
 122
 123   bool add(const std::string& key, const std::string& value, size_t value_length)
 124   {
 125     memcached_return rc= memcached_add(&memc, key.c_str(), key.length(),
 126                                        value.c_str(), value_length, 0, 0);
 127     return (rc == MEMCACHED_SUCCESS);
 128   }
 129
 130   bool add_by_key(const std::string& master_key, const std::string& key,
 131                   const std::string& value, size_t value_length)
 132   {
 133     memcached_return rc= memcached_add_by_key(&memc,
 134                                               master_key.c_str(),
 135                                               master_key.length(),
 136                                               key.c_str(),
 137                                               key.length(),
 138                                               value.c_str(),
 139                                               value_length,
 140                                               0, 0);
 141     return (rc == MEMCACHED_SUCCESS);
 142   }
 143
 144   bool replace(const std::string& key, const std::string& value,
 145                size_t value_length)
 146   {
 147     memcached_return rc= memcached_replace(&memc, key.c_str(), key.length(),
 148                                            value.c_str(), value_length,
 149                                            0, 0);
 150     return (rc == MEMCACHED_SUCCESS);
 151   }
 152
 153   bool replace_by_key(const std::string& master_key, const std::string& key,
 154                       const std::string& value, size_t value_length)
 155   {
 156     memcached_return rc= memcached_replace_by_key(&memc,
 157                                                   master_key.c_str(),
 158                                                   master_key.length(),
 159                                                   key.c_str(),
 160                                                   key.length(),
 161                                                   value.c_str(),
 162                                                   value_length,
 163                                                   0, 0);
 164     return (rc == MEMCACHED_SUCCESS);
 165   }
 166
 167   bool prepend(const std::string& key, const std::string& value,
 168                size_t value_length)
 169   {
 170     memcached_return rc= memcached_prepend(&memc, key.c_str(), key.length(),
 171                                            value.c_str(), value_length, 0, 0);
 172     return (rc == MEMCACHED_SUCCESS);
 173   }
 174
 175   bool prepend_by_key(const std::string& master_key, const std::string& key,
 176                       const std::string& value, size_t value_length)
 177   {
 178     memcached_return rc= memcached_prepend_by_key(&memc,
 179                                                   master_key.c_str(),
 180                                                   master_key.length(),
 181                                                   key.c_str(),
 182                                                   key.length(),
 183                                                   value.c_str(),
 184                                                   value_length,
 185                                                   0,
 186                                                   0);
 187     return (rc == MEMCACHED_SUCCESS);
 188   }
 189
 190   bool append(const std::string& key, const std::string& value,
 191               size_t value_length)
 192   {
 193     memcached_return rc= memcached_append(&memc,
 194                                           key.c_str(),
 195                                           key.length(),
 196                                           value.c_str(),
 197                                           value_length, 0, 0);
 198     return (rc == MEMCACHED_SUCCESS);
 199   }
 200
 201   bool append_by_key(const std::string& master_key, const std::string& key,
 202                      const std::string& value, size_t value_length)
 203   {
 204     memcached_return rc= memcached_append_by_key(&memc,
 205                                                  master_key.c_str(),
 206                                                  master_key.length(),
 207                                                  key.c_str(),
 208                                                  key.length(),
 209                                                  value.c_str(),
 210                                                  value_length, 0, 0);
 211     return (rc == MEMCACHED_SUCCESS);
 212   }
 213
 214   bool cas(const std::string& key, const std::string& value,
 215            size_t value_length, uint64_t cas_arg)
 216   {
 217     memcached_return rc= memcached_cas(&memc, key.c_str(), key.length(),
 218                                        value.c_str(), value_length, 0, 0, cas_arg);
 219     return (rc == MEMCACHED_SUCCESS);
 220   }
 221
 222   bool cas_by_key(const std::string& master_key, const std::string& key,
 223                   const std::string& value, size_t value_length,
 224                   uint64_t cas_arg)
 225   {
 226     memcached_return rc= memcached_cas_by_key(&memc,
 227                                               master_key.c_str(),
 228                                               master_key.length(),
 229                                               key.c_str(),
 230                                               key.length(),
 231                                               value.c_str(),
 232                                               value_length,
 233                                               0, 0, cas_arg);
 234     return (rc == MEMCACHED_SUCCESS);
 235   }
 236
 237   // using 'remove' vs. 'delete' since 'delete' is a keyword
 238   bool remove(const std::string& key)
 239   {
 240     memcached_return rc= memcached_delete(&memc, key.c_str(), key.length(), 0);
 241     return (rc == MEMCACHED_SUCCESS);
 242   }
 243
 244   bool delete_by_key(const std::string& master_key,
 245                      const std::string& key)
 246   {
 247     memcached_return rc= memcached_delete_by_key(&memc,
 248                                                  master_key.c_str(),
 249                                                  master_key.length(),
 250                                                  key.c_str(),
 251                                                  key.length(),
 252                                                  0);
 253     return (rc == MEMCACHED_SUCCESS);
 254   }
 255
 256   const std::string lib_version() const
 257   {
 258     const char *ver= memcached_lib_version();
 259     const std::string version(ver);
 260     return version;
 261   }
 262
 263 private:
 264   memcached_st memc;
 265   memcached_result_st result;
 266 };