tabwidthbug

C code posted
created at 22 Jun 22:10

Edit | Back
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
#ifndef KEYSPACE_CLIENT_H
#define KEYSPACE_CLIENT_H

#include <stdint.h>

#ifdef __cplusplus
extern "C" {
#endif

/*
 * Status values. 
 * When using as a return value, negative values mean error.
 *
 * NOTMASTER is returned when a write or safe read operation was sent to a
 *  non-master server.
 * FAILED is returned when the operation failed, e.g. when there is no value to
 *  the key.
 * ERROR is returned when the connection closes unexpectedly or timeout occurs.
 */
#define KEYSPACE_OK          0
#define KEYSPACE_NOTMASTER      -1
#define KEYSPACE_FAILED        -2
#define KEYSPACE_ERROR        -3

#define KEYSPACE_INVALID_RESULT    NULL

typedef void * keyspace_client_t;
typedef void * keyspace_result_t;

/*
 * Get the result of the last operation
 *
 * Parameters:
 *  kc:    client object
 *  status: return the status of the operation
 *
 * Return value: the result object or KEYSPACE_INVALID_RESULT in case of error
 */ 
keyspace_result_t keyspace_client_result(keyspace_client_t kc, int *status);

/*
 * Close the result object and free allocated memory.
 */
void keyspace_result_close(keyspace_result_t kr);

/*
 * Get the next result.
 *
 * Parameters:
 *  kr:    result object
 *  status: return the status of the operation
 *
 * Return value: the result object or KEYSPACE_INVALID_RESULT in case of error
 */ 
keyspace_result_t keyspace_result_next(keyspace_result_t kr, int *status);

/*
 * Get the status of the last operation.
 *
 * Parameters:
 *  kr:    result object
 *
 * Return value: the status of the operation
 */
int  keyspace_result_status(keyspace_result_t kr);

/*
 * Get the key data of the result (if any)
 *
 * Parameters:
 *  kr:    result object
 *  keylen:  return the length of the key data
 *
 * Return value: pointer to the key data that is keylen long or 
 *  NULL if there is no data
 */
const void * keyspace_result_key(keyspace_result_t kr, unsigned *keylen);

/*
 * Get the value data of the result (if any)
 *
 * Parameters:
 *  kr:    result object
 *  vallen:  return the length of the value data
 *
 * Return value: pointer to the value data that is vallen long or 
 *  NULL if there is no data
 */
const void * keyspace_result_value(keyspace_result_t kr, unsigned *vallen);


/*
 * Create client object
 *
 * Return value: the new client object
 */
keyspace_client_t keyspace_client_create();

/*
 * Destroy client object
 *
 * Parameters:
 *  kc:    client object
 */
void keyspace_client_destroy(keyspace_client_t kc);

/*
 * Initialize client object. Set up nodes and timeout, connect to one of the
 * nodes.
 *
 * Parameters:
 *  kc:      client object
 *  nodec:    number of node names to use
 *  nodev:    array of node names
 *  timeout:  socket timeout
 *
 * Return value: the status of the operation
 */
int  keyspace_client_init(keyspace_client_t kc,
    int nodec, const char* nodev[], 
    uint64_t timeout);

/*
 * Get the master node.
 *
 * Parameters:
 *  kc:    client object
 *
 * Return value: the number of the master node or the error status of the 
 * operation when negative.
 */
int  keyspace_client_get_master(keyspace_client_t kc);

/*
 * GET operation with user-provided buffer.
 *
 * Return the value of a key, if it exists in the database. 
 *
 * Parameters:
 *  kc:    client object
 *  key:  buffer to the key data
 *  keylen:  length of the key
 *  val:  buffer to the value data
 *  vallen:  size of the buffer to the value
 *  dirty:  nonzero value denotes dirty operation
 *
 * Return value: the size of the key, or error when negative. If exceeds vallen,
 *  the value is not copied into val.
 */
int  keyspace_client_get_simple(keyspace_client_t kc, 
    const void *key, unsigned keylen, 
    void *val, unsigned vallen, 
    int dirty);

/*
 * GET operation.
 *
 * Return the value of a key, if it exists in the database. 
 * You get the result with keyspace_client_result().
 *
 * Parameters:
 *  kc:    client object
 *  key:  buffer to the key data
 *  keylen:  length of the key
 *  dirty:  nonzero value denotes dirty operation
 *
 * Return value: the status of the operation
 */
int  keyspace_client_get(keyspace_client_t kc, 
    const void *key, unsigned keylen, 
    int dirty);

/*
 * LISTKEYS operation.
 *
 * Return at most count 'keys' starting with 'prefix'.
 * You get the result with keyspace_client_result().
 *
 * Parameters:
 *  kc:      client object
 *  prefix:    buffer to the prefix data
 *  prefixlen:  length of the prefix
 *  start_key:  buffer to the starting key
 *  sklen:    length of the starting key
 *  count:    limit the number of results to this value
 *  skip:    skip that much items in the result
 *  dirty:    nonzero value denotes dirty operation
 *
 * Return value: the status of the operation
 */
int  keyspace_client_list_keys(keyspace_client_t kc, 
    const void *prefix, unsigned prefixlen,
    const void *start_key, unsigned sklen,
    uint64_t count,
    int skip,
    int dirty);


/*
 * LISTKEYVALUES operation.
 *
 * Return at most 'count' keys and their values starting with 'prefix'.
 * You get the result with keyspace_client_result().
 *
 * Parameters:
 *  kc:      client object
 *  prefix:    buffer to the prefix data
 *  prefixlen:  length of the prefix
 *  start_key:  buffer to the starting key
 *  sklen:    length of the starting key
 *  count:    limit the number of results to this value
 *  skip:    skip that much items in the result
 *  dirty:    nonzero value denotes dirty operation
 *
 * Return value: the status of the operation
 */
int keyspace_client_list_keyvalues(keyspace_client_t kc, 
    const void *prefix, unsigned prefixlen,
    const void *start_key, unsigned sklen,
    uint64_t count,
    int skip,
    int dirty);

/*
 * SET operation.
 *
 * Set the value of 'key', overwriting the previous value if it already existed
 * in the database.
 *
 * Parameters:
 *  kc:      client object
 *  key:    buffer to the key data
 *  keylen:    length of the key
 *  val:    buffer to the value data
 *  vallen:    length of the value
 *  submit:    nonzero value submits the operation automatically
 *
 * Return value: the status of the operation
 */
int  keyspace_client_set(keyspace_client_t kc,
    const void *key, unsigned keylen,
    const void *val, unsigned vallen,
    int submit);


/*
 * TEST-AND-SET operation.
 *
 * Changes the value of 'key' to 'value' if its current value is 'test'.
 * 
 * Parameters:
 *  kc:      client object
 *  key:    buffer to the key data
 *  keylen:    length of the key
 *  test:    buffer to the test data
 *  testlen:  length of the test
 *  val:    buffer to the value data
 *  vallen:    length of the value
 *  submit:    nonzero value submits the operation automatically
 *
 * Return value: the status of the operation
 */
int  keyspace_client_test_and_set(keyspace_client_t kc,
    const void *key, unsigned keylen,
    const void *test, unsigned testlen,
    const void *val, unsigned vallen,
    int submit);

/*
 * ADD operation.
 *
 * Treats the value of 'key' as a number and atomically increments it by 'num',
 * where 'num' may be a negative number.
 * 
 * Parameters:
 *  kc:      client object
 *  key:    buffer to the key data
 *  keylen:    length of the key
 *  num:    increment the value by this number
 *  result:    return the resulting value
 *  submit:    nonzero value submits the operation automatically
 *
 * Return value: the status of the operation
 */
int  keyspace_client_add(keyspace_client_t kc,
    const void *key, unsigned keylen,
    int64_t num,
    int64_t *result,
    int submit);

/*
 * DELETE operation.
 *
 * Delete 'key' and its value from the database.
 * 
 * Parameters:
 *  kc:      client object
 *  key:    buffer to the key data
 *  keylen:    length of the key
 *  submit:    nonzero value submits the operation automatically
 *
 * Return value: the status of the operation
 */
int  keyspace_client_delete(keyspace_client_t kc,
    const void *key, unsigned keylen,
    int submit);

/*
 * REMOVE operation.
 *
 * Delete 'key' and its value from the database, and return the value.
 * 
 * Parameters:
 *  kc:      client object
 *  key:    buffer to the key data
 *  keylen:    length of the key
 *  submit:    nonzero value submits the operation automatically
 *
 * Return value: the status of the operation
 */
int keyspace_client_remove(keyspace_client_t kc,
    const void *key, unsigned keylen,
    int submit);

/*
 * RENAME operation.
 *
 * Rename key named 'from' to key named 'to'.
 * 
 * Parameters:
 *  kc:      client object
 *  from:    buffer to the name
 *  keylen:    length of the from
 *  to:      buffer to the name
 *  tolen:    length of the to
 *  submit:    nonzero value submits the operation automatically
 *
 * Return value: the status of the operation
 */
int keyspace_client_rename(keyspace_client_t kc,
    const void *from, unsigned fromlen,
    const void *to, unsigned tolen,
    int submit);


/*
 * PRUNE operation
 *
 * Delete all key starting with 'prefix' from the database.
 *
 * Parameters:
 *  kc:      client object
 *  prefix:    buffer to the prefix
 *  prefixlen:  length of the prefix
 *  submit:    nonzero value submits the operation automatically
 *
 * Return value: the status of the operation
 */
int keyspace_client_prune(keyspace_client_t kc,
    const void *prefix, unsigned prefixlen,
    int submit);

/*
 * Begin grouping commands.
 *
 * You can group several write operations and submit them as one. Before
 * grouping commands you have to call this function, and then call write
 * operations with 'submit' parameter set to 0.
 * 
 * Parameters:
 *  kc:      client object
 *
 * Return value: the status of the operation
 */
int  keyspace_client_begin(keyspace_client_t kc);

/*
 * Submit grouped commands.
 *
 * This function waits for all the grouped operations to complete. If any of
 * the operations fail, the return value of this function will be negative.
 * 
 * Parameters:
 *  kc:      client object
 *
 * Return value: the status of the grouped operations.
 */
int  keyspace_client_submit(keyspace_client_t kc);


#ifdef __cplusplus
}
#endif

#endif
9.92 KB in 12 ms with coderay