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

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