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

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