memcached/CppProducer/memcached.hh

/* 
  based on original memcached.hh from libmemcached 0.31
  additions:  
     server_add() 
     std::string overloads for set(), get(), remove()
 
 */

#include "libmemcached/memcached.h"
#include <string>
#include <string.h>
#include <stdio.h>

class Memcached
{
  memcached_st memc;
  memcached_result_st result;

public:

  Memcached() : memc(), result()
  {
    memcached_create(&memc);
  }

  Memcached(memcached_st *clone) : memc(), result()
  {
    memcached_clone(&memc, clone);
  }
  char *fetch (char *key, size_t *key_length, size_t *value_length)
  {
    uint32_t flags;
    memcached_return rc;

    return memcached_fetch(&memc, key, key_length,
                    value_length, &flags, &rc);
  }


  char *get(std::string key, size_t *value_length)
  {
    return get(key.c_str(), value_length);
  }

  char *get(const char *key, size_t *value_length)
  {
    uint32_t flags;
    memcached_return rc;

    return memcached_get(&memc, key, strlen(key),
                         value_length, &flags, &rc);
  }

  char *get_by_key(const char *master_key, const char *key, 
                   size_t *value_length)
  {
    uint32_t flags;
    memcached_return rc;

    return memcached_get_by_key(&memc, master_key, strlen(master_key), 
                                key, strlen(key),
                                value_length, &flags, &rc);
  }

  memcached_return mget(char **keys, size_t *key_length, 
                        unsigned int number_of_keys)
  {

    return memcached_mget(&memc, keys, key_length, number_of_keys);
  }


  memcached_return set(std::string key, const char *value, size_t value_length, unsigned int expire=0)
  {
    return set(key.c_str(), value, value_length, expire);
  }

  memcached_return set(const char *key, const char *value, size_t value_length, unsigned int expire=0)
  {
    return memcached_set(&memc, key, strlen(key),
                         value, value_length,
                         time_t(expire), uint32_t(0));
  }

  memcached_return set_by_key(const char *master_key, const char *key, 
                              const char *value, size_t value_length)
  {
    return memcached_set_by_key(&memc, master_key, strlen(master_key),
                         key, strlen(key),
                         value, value_length,
                         time_t(0),
                         uint32_t(0) );
  }
  memcached_return
    increment(const char *key, unsigned int offset, uint64_t *value)
  {
    return memcached_increment(&memc, key, strlen(key),
                         offset, value);
  }
  memcached_return
    decrement(const char *key, unsigned int offset, uint64_t *value)
  {
    return memcached_decrement(&memc, key, strlen(key),
                         offset, value);
  }


  memcached_return add(const char *key, const char *value, size_t value_length)
  {
    return memcached_add(&memc, key, strlen(key), value, value_length, 0, 0);
  }
  memcached_return add_by_key(const char *master_key, const char *key, 
                              const char *value, size_t value_length)
  {
    return memcached_add_by_key(&memc, master_key, strlen(master_key),
                                key, strlen(key),
                                value, value_length,
                                0, 0);
  }

  memcached_return replace(const char *key, const char *value, 
                           size_t value_length)
  {
    return memcached_replace(&memc, key, strlen(key),
                     value, value_length,
                     0, 0);
  }
  memcached_return replace_by_key(const char *master_key, const char *key, 
                                  const char *value, size_t value_length)
  {
    return memcached_replace_by_key(&memc, master_key, strlen(master_key),
                                    key, strlen(key),
                                    value, value_length, 0, 0);
  }

  memcached_return prepend(const char *key, const char *value, 
                           size_t value_length)
  {
    return memcached_prepend(&memc, key, strlen(key),
                    value, value_length, 0, 0);
  }
  memcached_return prepend_by_key(const char *master_key, const char *key, 
                                  const char *value, size_t value_length)
  {
    return memcached_prepend_by_key(&memc, master_key, strlen(master_key),
                                    key, strlen(key),
                                    value, value_length,
                                    0,
                                    0);
  }

  memcached_return  append(const char *key, const char *value, 
                           size_t value_length)
  {
    return memcached_append(&memc, key, strlen(key),
                    value, value_length, 0, 0);
  }
  memcached_return  append_by_key(const char *master_key, const char *key, 
                                  const char *value, size_t value_length)
  {
    return memcached_append_by_key(&memc,
                                   master_key, strlen(master_key),
                                   key, strlen(key),
                                   value, value_length, 0, 0);
  }
  memcached_return  cas(const char *key, const char *value, 
                        size_t value_length, uint64_t cas_arg)
  {
    return memcached_cas(&memc, key, strlen(key),
                    value, value_length, 0, 0, cas_arg);
  }
  memcached_return  cas_by_key(const char *master_key, const char *key, 
                               const char *value, size_t value_length, 
                               uint64_t cas_arg)
  {
    return memcached_cas_by_key(&memc,
                                master_key, strlen(master_key),
                                key, strlen(key),
                                value, value_length,
                                0, 0, cas_arg);
  }
  // using 'remove' vs. 'delete' since 'delete' is a keyword 

  memcached_return remove(std::string key)
  {
    return remove(key.c_str());
  }

  memcached_return remove(const char *key)
  {
    return memcached_delete (&memc, key, strlen(key), 0);

  }
  memcached_return delete_by_key(const char *master_key, const char *key)
  {
    return memcached_delete_by_key(&memc, master_key, strlen(master_key),
                           key, strlen(key), 0);
  }

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