~maria-captains/maria/5.5-cassandra-parallel
» Revision
3516
: storage/cassandra/gen-cpp-async/Cassandra.h
« back to all changes in this revision
Viewing changes to storage/cassandra/gen-cpp-async/Cassandra.h
- browse files at revision 3516
- compare with another revision
- compare with revision 3517
- download diff
- download tarball
- view history from revision 3516
- Committer: Sergey Petrunya
- Date: 2012-09-20 14:32:37 UTC
- Revision ID: psergey@askmonty.org-20120920143237-og4d9qh8uiojasmi
Casandra SE:
- Introduce asynchronous operations
- parallel INSERT operation.
- Introduce asynchronous operations
- parallel INSERT operation.
- files added:
- storage/cassandra/gen-cpp-async
- files modified:
- storage/cassandra/CMakeLists.txt
added
removed
storage/cassandra/gen-cpp-async/Cassandra.h
1
/**
2
* Autogenerated by Thrift Compiler (0.9.0-dev)
3
*
4
* DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5
* @generated
6
*/
7
#ifndef Cassandra_H
8
#define Cassandra_H
9
10
#include <thrift/TDispatchProcessor.h>
11
#include "cassandra_types.h"
12
13
namespace org { namespace apache { namespace cassandra {
14
15
// next line added by psergey
16
namespace apache = ::apache;
17
18
class CassandraIf {
19
public:
20
virtual ~CassandraIf() {}
21
virtual void login(const AuthenticationRequest& auth_request) = 0;
22
virtual void set_keyspace(const std::string& keyspace) = 0;
23
virtual void get(ColumnOrSuperColumn& _return, const std::string& key, const ColumnPath& column_path, const ConsistencyLevel::type consistency_level) = 0;
24
virtual void get_slice(std::vector<ColumnOrSuperColumn> & _return, const std::string& key, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level) = 0;
25
virtual int32_t get_count(const std::string& key, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level) = 0;
26
virtual void multiget_slice(std::map<std::string, std::vector<ColumnOrSuperColumn> > & _return, const std::vector<std::string> & keys, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level) = 0;
27
virtual void multiget_count(std::map<std::string, int32_t> & _return, const std::vector<std::string> & keys, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level) = 0;
28
virtual void get_range_slices(std::vector<KeySlice> & _return, const ColumnParent& column_parent, const SlicePredicate& predicate, const KeyRange& range, const ConsistencyLevel::type consistency_level) = 0;
29
virtual void get_paged_slice(std::vector<KeySlice> & _return, const std::string& column_family, const KeyRange& range, const std::string& start_column, const ConsistencyLevel::type consistency_level) = 0;
30
virtual void get_indexed_slices(std::vector<KeySlice> & _return, const ColumnParent& column_parent, const IndexClause& index_clause, const SlicePredicate& column_predicate, const ConsistencyLevel::type consistency_level) = 0;
31
virtual void insert(const std::string& key, const ColumnParent& column_parent, const Column& column, const ConsistencyLevel::type consistency_level) = 0;
32
virtual void add(const std::string& key, const ColumnParent& column_parent, const CounterColumn& column, const ConsistencyLevel::type consistency_level) = 0;
33
virtual void remove(const std::string& key, const ColumnPath& column_path, const int64_t timestamp, const ConsistencyLevel::type consistency_level) = 0;
34
virtual void remove_counter(const std::string& key, const ColumnPath& path, const ConsistencyLevel::type consistency_level) = 0;
35
virtual void batch_mutate(const std::map<std::string, std::map<std::string, std::vector<Mutation> > > & mutation_map, const ConsistencyLevel::type consistency_level) = 0;
36
virtual void truncate(const std::string& cfname) = 0;
37
virtual void describe_schema_versions(std::map<std::string, std::vector<std::string> > & _return) = 0;
38
virtual void describe_keyspaces(std::vector<KsDef> & _return) = 0;
39
virtual void describe_cluster_name(std::string& _return) = 0;
40
virtual void describe_version(std::string& _return) = 0;
41
virtual void describe_ring(std::vector<TokenRange> & _return, const std::string& keyspace) = 0;
42
virtual void describe_token_map(std::map<std::string, std::string> & _return) = 0;
43
virtual void describe_partitioner(std::string& _return) = 0;
44
virtual void describe_snitch(std::string& _return) = 0;
45
virtual void describe_keyspace(KsDef& _return, const std::string& keyspace) = 0;
46
virtual void describe_splits(std::vector<std::string> & _return, const std::string& cfName, const std::string& start_token, const std::string& end_token, const int32_t keys_per_split) = 0;
47
virtual void system_add_column_family(std::string& _return, const CfDef& cf_def) = 0;
48
virtual void system_drop_column_family(std::string& _return, const std::string& column_family) = 0;
49
virtual void system_add_keyspace(std::string& _return, const KsDef& ks_def) = 0;
50
virtual void system_drop_keyspace(std::string& _return, const std::string& keyspace) = 0;
51
virtual void system_update_keyspace(std::string& _return, const KsDef& ks_def) = 0;
52
virtual void system_update_column_family(std::string& _return, const CfDef& cf_def) = 0;
53
virtual void execute_cql_query(CqlResult& _return, const std::string& query, const Compression::type compression) = 0;
54
virtual void prepare_cql_query(CqlPreparedResult& _return, const std::string& query, const Compression::type compression) = 0;
55
virtual void execute_prepared_cql_query(CqlResult& _return, const int32_t itemId, const std::vector<std::string> & values) = 0;
56
virtual void set_cql_version(const std::string& version) = 0;
57
};
58
59
class CassandraIfFactory {
60
public:
61
typedef CassandraIf Handler;
62
63
virtual ~CassandraIfFactory() {}
64
65
virtual CassandraIf* getHandler(const ::apache::thrift::TConnectionInfo& connInfo) = 0;
66
virtual void releaseHandler(CassandraIf* /* handler */) = 0;
67
};
68
69
class CassandraIfSingletonFactory : virtual public CassandraIfFactory {
70
public:
71
CassandraIfSingletonFactory(const boost::shared_ptr<CassandraIf>& iface) : iface_(iface) {}
72
virtual ~CassandraIfSingletonFactory() {}
73
74
virtual CassandraIf* getHandler(const ::apache::thrift::TConnectionInfo&) {
75
return iface_.get();
76
}
77
virtual void releaseHandler(CassandraIf* /* handler */) {}
78
79
protected:
80
boost::shared_ptr<CassandraIf> iface_;
81
};
82
83
class CassandraNull : virtual public CassandraIf {
84
public:
85
virtual ~CassandraNull() {}
86
void login(const AuthenticationRequest& /* auth_request */) {
87
return;
88
}
89
void set_keyspace(const std::string& /* keyspace */) {
90
return;
91
}
92
void get(ColumnOrSuperColumn& /* _return */, const std::string& /* key */, const ColumnPath& /* column_path */, const ConsistencyLevel::type /* consistency_level */) {
93
return;
94
}
95
void get_slice(std::vector<ColumnOrSuperColumn> & /* _return */, const std::string& /* key */, const ColumnParent& /* column_parent */, const SlicePredicate& /* predicate */, const ConsistencyLevel::type /* consistency_level */) {
96
return;
97
}
98
int32_t get_count(const std::string& /* key */, const ColumnParent& /* column_parent */, const SlicePredicate& /* predicate */, const ConsistencyLevel::type /* consistency_level */) {
99
int32_t _return = 0;
100
return _return;
101
}
102
void multiget_slice(std::map<std::string, std::vector<ColumnOrSuperColumn> > & /* _return */, const std::vector<std::string> & /* keys */, const ColumnParent& /* column_parent */, const SlicePredicate& /* predicate */, const ConsistencyLevel::type /* consistency_level */) {
103
return;
104
}
105
void multiget_count(std::map<std::string, int32_t> & /* _return */, const std::vector<std::string> & /* keys */, const ColumnParent& /* column_parent */, const SlicePredicate& /* predicate */, const ConsistencyLevel::type /* consistency_level */) {
106
return;
107
}
108
void get_range_slices(std::vector<KeySlice> & /* _return */, const ColumnParent& /* column_parent */, const SlicePredicate& /* predicate */, const KeyRange& /* range */, const ConsistencyLevel::type /* consistency_level */) {
109
return;
110
}
111
void get_paged_slice(std::vector<KeySlice> & /* _return */, const std::string& /* column_family */, const KeyRange& /* range */, const std::string& /* start_column */, const ConsistencyLevel::type /* consistency_level */) {
112
return;
113
}
114
void get_indexed_slices(std::vector<KeySlice> & /* _return */, const ColumnParent& /* column_parent */, const IndexClause& /* index_clause */, const SlicePredicate& /* column_predicate */, const ConsistencyLevel::type /* consistency_level */) {
115
return;
116
}
117
void insert(const std::string& /* key */, const ColumnParent& /* column_parent */, const Column& /* column */, const ConsistencyLevel::type /* consistency_level */) {
118
return;
119
}
120
void add(const std::string& /* key */, const ColumnParent& /* column_parent */, const CounterColumn& /* column */, const ConsistencyLevel::type /* consistency_level */) {
121
return;
122
}
123
void remove(const std::string& /* key */, const ColumnPath& /* column_path */, const int64_t /* timestamp */, const ConsistencyLevel::type /* consistency_level */) {
124
return;
125
}
126
void remove_counter(const std::string& /* key */, const ColumnPath& /* path */, const ConsistencyLevel::type /* consistency_level */) {
127
return;
128
}
129
void batch_mutate(const std::map<std::string, std::map<std::string, std::vector<Mutation> > > & /* mutation_map */, const ConsistencyLevel::type /* consistency_level */) {
130
return;
131
}
132
void truncate(const std::string& /* cfname */) {
133
return;
134
}
135
void describe_schema_versions(std::map<std::string, std::vector<std::string> > & /* _return */) {
136
return;
137
}
138
void describe_keyspaces(std::vector<KsDef> & /* _return */) {
139
return;
140
}
141
void describe_cluster_name(std::string& /* _return */) {
142
return;
143
}
144
void describe_version(std::string& /* _return */) {
145
return;
146
}
147
void describe_ring(std::vector<TokenRange> & /* _return */, const std::string& /* keyspace */) {
148
return;
149
}
150
void describe_token_map(std::map<std::string, std::string> & /* _return */) {
151
return;
152
}
153
void describe_partitioner(std::string& /* _return */) {
154
return;
155
}
156
void describe_snitch(std::string& /* _return */) {
157
return;
158
}
159
void describe_keyspace(KsDef& /* _return */, const std::string& /* keyspace */) {
160
return;
161
}
162
void describe_splits(std::vector<std::string> & /* _return */, const std::string& /* cfName */, const std::string& /* start_token */, const std::string& /* end_token */, const int32_t /* keys_per_split */) {
163
return;
164
}
165
void system_add_column_family(std::string& /* _return */, const CfDef& /* cf_def */) {
166
return;
167
}
168
void system_drop_column_family(std::string& /* _return */, const std::string& /* column_family */) {
169
return;
170
}
171
void system_add_keyspace(std::string& /* _return */, const KsDef& /* ks_def */) {
172
return;
173
}
174
void system_drop_keyspace(std::string& /* _return */, const std::string& /* keyspace */) {
175
return;
176
}
177
void system_update_keyspace(std::string& /* _return */, const KsDef& /* ks_def */) {
178
return;
179
}
180
void system_update_column_family(std::string& /* _return */, const CfDef& /* cf_def */) {
181
return;
182
}
183
void execute_cql_query(CqlResult& /* _return */, const std::string& /* query */, const Compression::type /* compression */) {
184
return;
185
}
186
void prepare_cql_query(CqlPreparedResult& /* _return */, const std::string& /* query */, const Compression::type /* compression */) {
187
return;
188
}
189
void execute_prepared_cql_query(CqlResult& /* _return */, const int32_t /* itemId */, const std::vector<std::string> & /* values */) {
190
return;
191
}
192
void set_cql_version(const std::string& /* version */) {
193
return;
194
}
195
};
196
197
198
class Cassandra_login_args {
199
public:
200
201
Cassandra_login_args() {
202
}
203
204
virtual ~Cassandra_login_args() throw() {}
205
206
AuthenticationRequest auth_request;
207
208
void __set_auth_request(const AuthenticationRequest& val) {
209
auth_request = val;
210
}
211
212
bool operator == (const Cassandra_login_args & rhs) const
213
{
214
if (!(auth_request == rhs.auth_request))
215
return false;
216
return true;
217
}
218
bool operator != (const Cassandra_login_args &rhs) const {
219
return !(*this == rhs);
220
}
221
222
bool operator < (const Cassandra_login_args & ) const;
223
224
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
225
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
226
227
};
228
229
230
class Cassandra_login_pargs {
231
public:
232
233
234
virtual ~Cassandra_login_pargs() throw() {}
235
236
const AuthenticationRequest* auth_request;
237
238
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
239
240
};
241
242
typedef struct _Cassandra_login_result__isset {
243
_Cassandra_login_result__isset() : failure(false), authnx(false), authzx(false) {}
244
bool failure;
245
bool authnx;
246
bool authzx;
247
} _Cassandra_login_result__isset;
248
249
class Cassandra_login_result {
250
public:
251
252
Cassandra_login_result() {
253
}
254
255
virtual ~Cassandra_login_result() throw() {}
256
257
typedef apache::thrift::TApplicationException failure_t;
258
typedef bool success_constref_nonvoid_t;
259
typedef void success_constref_t;
260
typedef bool success_nonvoid_t;
261
typedef void success_t;
262
apache::thrift::TApplicationException failure;
263
AuthenticationException authnx;
264
AuthorizationException authzx;
265
266
_Cassandra_login_result__isset __isset;
267
268
void __set_failure(const apache::thrift::TApplicationException& val) {
269
failure = val;
270
}
271
272
void __set_authnx(const AuthenticationException& val) {
273
authnx = val;
274
}
275
276
void __set_authzx(const AuthorizationException& val) {
277
authzx = val;
278
}
279
280
bool operator == (const Cassandra_login_result & rhs) const
281
{
282
if (!(authnx == rhs.authnx))
283
return false;
284
if (!(authzx == rhs.authzx))
285
return false;
286
return true;
287
}
288
bool operator != (const Cassandra_login_result &rhs) const {
289
return !(*this == rhs);
290
}
291
292
bool operator < (const Cassandra_login_result & ) const;
293
294
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
295
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
296
297
};
298
299
typedef struct _Cassandra_login_presult__isset {
300
_Cassandra_login_presult__isset() : failure(false), authnx(false), authzx(false) {}
301
bool failure;
302
bool authnx;
303
bool authzx;
304
} _Cassandra_login_presult__isset;
305
306
class Cassandra_login_presult {
307
public:
308
309
310
virtual ~Cassandra_login_presult() throw() {}
311
312
apache::thrift::TApplicationException* failure;
313
AuthenticationException authnx;
314
AuthorizationException authzx;
315
316
_Cassandra_login_presult__isset __isset;
317
318
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
319
320
};
321
322
323
class Cassandra_set_keyspace_args {
324
public:
325
326
Cassandra_set_keyspace_args() : keyspace() {
327
}
328
329
virtual ~Cassandra_set_keyspace_args() throw() {}
330
331
std::string keyspace;
332
333
void __set_keyspace(const std::string& val) {
334
keyspace = val;
335
}
336
337
bool operator == (const Cassandra_set_keyspace_args & rhs) const
338
{
339
if (!(keyspace == rhs.keyspace))
340
return false;
341
return true;
342
}
343
bool operator != (const Cassandra_set_keyspace_args &rhs) const {
344
return !(*this == rhs);
345
}
346
347
bool operator < (const Cassandra_set_keyspace_args & ) const;
348
349
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
350
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
351
352
};
353
354
355
class Cassandra_set_keyspace_pargs {
356
public:
357
358
359
virtual ~Cassandra_set_keyspace_pargs() throw() {}
360
361
const std::string* keyspace;
362
363
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
364
365
};
366
367
typedef struct _Cassandra_set_keyspace_result__isset {
368
_Cassandra_set_keyspace_result__isset() : failure(false), ire(false) {}
369
bool failure;
370
bool ire;
371
} _Cassandra_set_keyspace_result__isset;
372
373
class Cassandra_set_keyspace_result {
374
public:
375
376
Cassandra_set_keyspace_result() {
377
}
378
379
virtual ~Cassandra_set_keyspace_result() throw() {}
380
381
typedef apache::thrift::TApplicationException failure_t;
382
typedef bool success_constref_nonvoid_t;
383
typedef void success_constref_t;
384
typedef bool success_nonvoid_t;
385
typedef void success_t;
386
apache::thrift::TApplicationException failure;
387
InvalidRequestException ire;
388
389
_Cassandra_set_keyspace_result__isset __isset;
390
391
void __set_failure(const apache::thrift::TApplicationException& val) {
392
failure = val;
393
}
394
395
void __set_ire(const InvalidRequestException& val) {
396
ire = val;
397
}
398
399
bool operator == (const Cassandra_set_keyspace_result & rhs) const
400
{
401
if (!(ire == rhs.ire))
402
return false;
403
return true;
404
}
405
bool operator != (const Cassandra_set_keyspace_result &rhs) const {
406
return !(*this == rhs);
407
}
408
409
bool operator < (const Cassandra_set_keyspace_result & ) const;
410
411
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
412
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
413
414
};
415
416
typedef struct _Cassandra_set_keyspace_presult__isset {
417
_Cassandra_set_keyspace_presult__isset() : failure(false), ire(false) {}
418
bool failure;
419
bool ire;
420
} _Cassandra_set_keyspace_presult__isset;
421
422
class Cassandra_set_keyspace_presult {
423
public:
424
425
426
virtual ~Cassandra_set_keyspace_presult() throw() {}
427
428
apache::thrift::TApplicationException* failure;
429
InvalidRequestException ire;
430
431
_Cassandra_set_keyspace_presult__isset __isset;
432
433
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
434
435
};
436
437
438
class Cassandra_get_args {
439
public:
440
441
Cassandra_get_args() : key(), consistency_level((ConsistencyLevel::type)1) {
442
consistency_level = (ConsistencyLevel::type)1;
443
444
}
445
446
virtual ~Cassandra_get_args() throw() {}
447
448
std::string key;
449
ColumnPath column_path;
450
ConsistencyLevel::type consistency_level;
451
452
void __set_key(const std::string& val) {
453
key = val;
454
}
455
456
void __set_column_path(const ColumnPath& val) {
457
column_path = val;
458
}
459
460
void __set_consistency_level(const ConsistencyLevel::type val) {
461
consistency_level = val;
462
}
463
464
bool operator == (const Cassandra_get_args & rhs) const
465
{
466
if (!(key == rhs.key))
467
return false;
468
if (!(column_path == rhs.column_path))
469
return false;
470
if (!(consistency_level == rhs.consistency_level))
471
return false;
472
return true;
473
}
474
bool operator != (const Cassandra_get_args &rhs) const {
475
return !(*this == rhs);
476
}
477
478
bool operator < (const Cassandra_get_args & ) const;
479
480
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
481
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
482
483
};
484
485
486
class Cassandra_get_pargs {
487
public:
488
489
490
virtual ~Cassandra_get_pargs() throw() {}
491
492
const std::string* key;
493
const ColumnPath* column_path;
494
const ConsistencyLevel::type* consistency_level;
495
496
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
497
498
};
499
500
typedef struct _Cassandra_get_result__isset {
501
_Cassandra_get_result__isset() : success(false), failure(false), ire(false), nfe(false), ue(false), te(false) {}
502
bool success;
503
bool failure;
504
bool ire;
505
bool nfe;
506
bool ue;
507
bool te;
508
} _Cassandra_get_result__isset;
509
510
class Cassandra_get_result {
511
public:
512
513
Cassandra_get_result() {
514
}
515
516
virtual ~Cassandra_get_result() throw() {}
517
518
typedef apache::thrift::TApplicationException failure_t;
519
typedef const ColumnOrSuperColumn& success_constref_nonvoid_t;
520
typedef const ColumnOrSuperColumn& success_constref_t;
521
typedef ColumnOrSuperColumn success_nonvoid_t;
522
typedef ColumnOrSuperColumn success_t;
523
ColumnOrSuperColumn success;
524
apache::thrift::TApplicationException failure;
525
InvalidRequestException ire;
526
NotFoundException nfe;
527
UnavailableException ue;
528
TimedOutException te;
529
530
_Cassandra_get_result__isset __isset;
531
532
void __set_success(const ColumnOrSuperColumn& val) {
533
success = val;
534
}
535
536
void __set_failure(const apache::thrift::TApplicationException& val) {
537
failure = val;
538
}
539
540
void __set_ire(const InvalidRequestException& val) {
541
ire = val;
542
}
543
544
void __set_nfe(const NotFoundException& val) {
545
nfe = val;
546
}
547
548
void __set_ue(const UnavailableException& val) {
549
ue = val;
550
}
551
552
void __set_te(const TimedOutException& val) {
553
te = val;
554
}
555
556
bool operator == (const Cassandra_get_result & rhs) const
557
{
558
if (!(success == rhs.success))
559
return false;
560
if (!(ire == rhs.ire))
561
return false;
562
if (!(nfe == rhs.nfe))
563
return false;
564
if (!(ue == rhs.ue))
565
return false;
566
if (!(te == rhs.te))
567
return false;
568
return true;
569
}
570
bool operator != (const Cassandra_get_result &rhs) const {
571
return !(*this == rhs);
572
}
573
574
bool operator < (const Cassandra_get_result & ) const;
575
576
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
577
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
578
579
};
580
581
typedef struct _Cassandra_get_presult__isset {
582
_Cassandra_get_presult__isset() : success(false), failure(false), ire(false), nfe(false), ue(false), te(false) {}
583
bool success;
584
bool failure;
585
bool ire;
586
bool nfe;
587
bool ue;
588
bool te;
589
} _Cassandra_get_presult__isset;
590
591
class Cassandra_get_presult {
592
public:
593
594
595
virtual ~Cassandra_get_presult() throw() {}
596
597
ColumnOrSuperColumn* success;
598
apache::thrift::TApplicationException* failure;
599
InvalidRequestException ire;
600
NotFoundException nfe;
601
UnavailableException ue;
602
TimedOutException te;
603
604
_Cassandra_get_presult__isset __isset;
605
606
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
607
608
};
609
610
611
class Cassandra_get_slice_args {
612
public:
613
614
Cassandra_get_slice_args() : key(), consistency_level((ConsistencyLevel::type)1) {
615
consistency_level = (ConsistencyLevel::type)1;
616
617
}
618
619
virtual ~Cassandra_get_slice_args() throw() {}
620
621
std::string key;
622
ColumnParent column_parent;
623
SlicePredicate predicate;
624
ConsistencyLevel::type consistency_level;
625
626
void __set_key(const std::string& val) {
627
key = val;
628
}
629
630
void __set_column_parent(const ColumnParent& val) {
631
column_parent = val;
632
}
633
634
void __set_predicate(const SlicePredicate& val) {
635
predicate = val;
636
}
637
638
void __set_consistency_level(const ConsistencyLevel::type val) {
639
consistency_level = val;
640
}
641
642
bool operator == (const Cassandra_get_slice_args & rhs) const
643
{
644
if (!(key == rhs.key))
645
return false;
646
if (!(column_parent == rhs.column_parent))
647
return false;
648
if (!(predicate == rhs.predicate))
649
return false;
650
if (!(consistency_level == rhs.consistency_level))
651
return false;
652
return true;
653
}
654
bool operator != (const Cassandra_get_slice_args &rhs) const {
655
return !(*this == rhs);
656
}
657
658
bool operator < (const Cassandra_get_slice_args & ) const;
659
660
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
661
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
662
663
};
664
665
666
class Cassandra_get_slice_pargs {
667
public:
668
669
670
virtual ~Cassandra_get_slice_pargs() throw() {}
671
672
const std::string* key;
673
const ColumnParent* column_parent;
674
const SlicePredicate* predicate;
675
const ConsistencyLevel::type* consistency_level;
676
677
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
678
679
};
680
681
typedef struct _Cassandra_get_slice_result__isset {
682
_Cassandra_get_slice_result__isset() : success(false), failure(false), ire(false), ue(false), te(false) {}
683
bool success;
684
bool failure;
685
bool ire;
686
bool ue;
687
bool te;
688
} _Cassandra_get_slice_result__isset;
689
690
class Cassandra_get_slice_result {
691
public:
692
693
Cassandra_get_slice_result() {
694
}
695
696
virtual ~Cassandra_get_slice_result() throw() {}
697
698
typedef apache::thrift::TApplicationException failure_t;
699
typedef const std::vector<ColumnOrSuperColumn> & success_constref_nonvoid_t;
700
typedef const std::vector<ColumnOrSuperColumn> & success_constref_t;
701
typedef std::vector<ColumnOrSuperColumn> success_nonvoid_t;
702
typedef std::vector<ColumnOrSuperColumn> success_t;
703
std::vector<ColumnOrSuperColumn> success;
704
apache::thrift::TApplicationException failure;
705
InvalidRequestException ire;
706
UnavailableException ue;
707
TimedOutException te;
708
709
_Cassandra_get_slice_result__isset __isset;
710
711
void __set_success(const std::vector<ColumnOrSuperColumn> & val) {
712
success = val;
713
}
714
715
void __set_failure(const apache::thrift::TApplicationException& val) {
716
failure = val;
717
}
718
719
void __set_ire(const InvalidRequestException& val) {
720
ire = val;
721
}
722
723
void __set_ue(const UnavailableException& val) {
724
ue = val;
725
}
726
727
void __set_te(const TimedOutException& val) {
728
te = val;
729
}
730
731
bool operator == (const Cassandra_get_slice_result & rhs) const
732
{
733
if (!(success == rhs.success))
734
return false;
735
if (!(ire == rhs.ire))
736
return false;
737
if (!(ue == rhs.ue))
738
return false;
739
if (!(te == rhs.te))
740
return false;
741
return true;
742
}
743
bool operator != (const Cassandra_get_slice_result &rhs) const {
744
return !(*this == rhs);
745
}
746
747
bool operator < (const Cassandra_get_slice_result & ) const;
748
749
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
750
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
751
752
};
753
754
typedef struct _Cassandra_get_slice_presult__isset {
755
_Cassandra_get_slice_presult__isset() : success(false), failure(false), ire(false), ue(false), te(false) {}
756
bool success;
757
bool failure;
758
bool ire;
759
bool ue;
760
bool te;
761
} _Cassandra_get_slice_presult__isset;
762
763
class Cassandra_get_slice_presult {
764
public:
765
766
767
virtual ~Cassandra_get_slice_presult() throw() {}
768
769
std::vector<ColumnOrSuperColumn> * success;
770
apache::thrift::TApplicationException* failure;
771
InvalidRequestException ire;
772
UnavailableException ue;
773
TimedOutException te;
774
775
_Cassandra_get_slice_presult__isset __isset;
776
777
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
778
779
};
780
781
782
class Cassandra_get_count_args {
783
public:
784
785
Cassandra_get_count_args() : key(), consistency_level((ConsistencyLevel::type)1) {
786
consistency_level = (ConsistencyLevel::type)1;
787
788
}
789
790
virtual ~Cassandra_get_count_args() throw() {}
791
792
std::string key;
793
ColumnParent column_parent;
794
SlicePredicate predicate;
795
ConsistencyLevel::type consistency_level;
796
797
void __set_key(const std::string& val) {
798
key = val;
799
}
800
801
void __set_column_parent(const ColumnParent& val) {
802
column_parent = val;
803
}
804
805
void __set_predicate(const SlicePredicate& val) {
806
predicate = val;
807
}
808
809
void __set_consistency_level(const ConsistencyLevel::type val) {
810
consistency_level = val;
811
}
812
813
bool operator == (const Cassandra_get_count_args & rhs) const
814
{
815
if (!(key == rhs.key))
816
return false;
817
if (!(column_parent == rhs.column_parent))
818
return false;
819
if (!(predicate == rhs.predicate))
820
return false;
821
if (!(consistency_level == rhs.consistency_level))
822
return false;
823
return true;
824
}
825
bool operator != (const Cassandra_get_count_args &rhs) const {
826
return !(*this == rhs);
827
}
828
829
bool operator < (const Cassandra_get_count_args & ) const;
830
831
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
832
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
833
834
};
835
836
837
class Cassandra_get_count_pargs {
838
public:
839
840
841
virtual ~Cassandra_get_count_pargs() throw() {}
842
843
const std::string* key;
844
const ColumnParent* column_parent;
845
const SlicePredicate* predicate;
846
const ConsistencyLevel::type* consistency_level;
847
848
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
849
850
};
851
852
typedef struct _Cassandra_get_count_result__isset {
853
_Cassandra_get_count_result__isset() : success(false), failure(false), ire(false), ue(false), te(false) {}
854
bool success;
855
bool failure;
856
bool ire;
857
bool ue;
858
bool te;
859
} _Cassandra_get_count_result__isset;
860
861
class Cassandra_get_count_result {
862
public:
863
864
Cassandra_get_count_result() : success(0) {
865
}
866
867
virtual ~Cassandra_get_count_result() throw() {}
868
869
typedef apache::thrift::TApplicationException failure_t;
870
typedef int32_t success_constref_nonvoid_t;
871
typedef int32_t success_constref_t;
872
typedef int32_t success_nonvoid_t;
873
typedef int32_t success_t;
874
int32_t success;
875
apache::thrift::TApplicationException failure;
876
InvalidRequestException ire;
877
UnavailableException ue;
878
TimedOutException te;
879
880
_Cassandra_get_count_result__isset __isset;
881
882
void __set_success(const int32_t val) {
883
success = val;
884
}
885
886
void __set_failure(const apache::thrift::TApplicationException& val) {
887
failure = val;
888
}
889
890
void __set_ire(const InvalidRequestException& val) {
891
ire = val;
892
}
893
894
void __set_ue(const UnavailableException& val) {
895
ue = val;
896
}
897
898
void __set_te(const TimedOutException& val) {
899
te = val;
900
}
901
902
bool operator == (const Cassandra_get_count_result & rhs) const
903
{
904
if (!(success == rhs.success))
905
return false;
906
if (!(ire == rhs.ire))
907
return false;
908
if (!(ue == rhs.ue))
909
return false;
910
if (!(te == rhs.te))
911
return false;
912
return true;
913
}
914
bool operator != (const Cassandra_get_count_result &rhs) const {
915
return !(*this == rhs);
916
}
917
918
bool operator < (const Cassandra_get_count_result & ) const;
919
920
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
921
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
922
923
};
924
925
typedef struct _Cassandra_get_count_presult__isset {
926
_Cassandra_get_count_presult__isset() : success(false), failure(false), ire(false), ue(false), te(false) {}
927
bool success;
928
bool failure;
929
bool ire;
930
bool ue;
931
bool te;
932
} _Cassandra_get_count_presult__isset;
933
934
class Cassandra_get_count_presult {
935
public:
936
937
938
virtual ~Cassandra_get_count_presult() throw() {}
939
940
int32_t* success;
941
apache::thrift::TApplicationException* failure;
942
InvalidRequestException ire;
943
UnavailableException ue;
944
TimedOutException te;
945
946
_Cassandra_get_count_presult__isset __isset;
947
948
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
949
950
};
951
952
953
class Cassandra_multiget_slice_args {
954
public:
955
956
Cassandra_multiget_slice_args() : consistency_level((ConsistencyLevel::type)1) {
957
consistency_level = (ConsistencyLevel::type)1;
958
959
}
960
961
virtual ~Cassandra_multiget_slice_args() throw() {}
962
963
std::vector<std::string> keys;
964
ColumnParent column_parent;
965
SlicePredicate predicate;
966
ConsistencyLevel::type consistency_level;
967
968
void __set_keys(const std::vector<std::string> & val) {
969
keys = val;
970
}
971
972
void __set_column_parent(const ColumnParent& val) {
973
column_parent = val;
974
}
975
976
void __set_predicate(const SlicePredicate& val) {
977
predicate = val;
978
}
979
980
void __set_consistency_level(const ConsistencyLevel::type val) {
981
consistency_level = val;
982
}
983
984
bool operator == (const Cassandra_multiget_slice_args & rhs) const
985
{
986
if (!(keys == rhs.keys))
987
return false;
988
if (!(column_parent == rhs.column_parent))
989
return false;
990
if (!(predicate == rhs.predicate))
991
return false;
992
if (!(consistency_level == rhs.consistency_level))
993
return false;
994
return true;
995
}
996
bool operator != (const Cassandra_multiget_slice_args &rhs) const {
997
return !(*this == rhs);
998
}
999
1000
bool operator < (const Cassandra_multiget_slice_args & ) const;
1001
1002
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1003
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1004
1005
};
1006
1007
1008
class Cassandra_multiget_slice_pargs {
1009
public:
1010
1011
1012
virtual ~Cassandra_multiget_slice_pargs() throw() {}
1013
1014
const std::vector<std::string> * keys;
1015
const ColumnParent* column_parent;
1016
const SlicePredicate* predicate;
1017
const ConsistencyLevel::type* consistency_level;
1018
1019
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1020
1021
};
1022
1023
typedef struct _Cassandra_multiget_slice_result__isset {
1024
_Cassandra_multiget_slice_result__isset() : success(false), failure(false), ire(false), ue(false), te(false) {}
1025
bool success;
1026
bool failure;
1027
bool ire;
1028
bool ue;
1029
bool te;
1030
} _Cassandra_multiget_slice_result__isset;
1031
1032
class Cassandra_multiget_slice_result {
1033
public:
1034
1035
Cassandra_multiget_slice_result() {
1036
}
1037
1038
virtual ~Cassandra_multiget_slice_result() throw() {}
1039
1040
typedef apache::thrift::TApplicationException failure_t;
1041
typedef const std::map<std::string, std::vector<ColumnOrSuperColumn> > & success_constref_nonvoid_t;
1042
typedef const std::map<std::string, std::vector<ColumnOrSuperColumn> > & success_constref_t;
1043
typedef std::map<std::string, std::vector<ColumnOrSuperColumn> > success_nonvoid_t;
1044
typedef std::map<std::string, std::vector<ColumnOrSuperColumn> > success_t;
1045
std::map<std::string, std::vector<ColumnOrSuperColumn> > success;
1046
apache::thrift::TApplicationException failure;
1047
InvalidRequestException ire;
1048
UnavailableException ue;
1049
TimedOutException te;
1050
1051
_Cassandra_multiget_slice_result__isset __isset;
1052
1053
void __set_success(const std::map<std::string, std::vector<ColumnOrSuperColumn> > & val) {
1054
success = val;
1055
}
1056
1057
void __set_failure(const apache::thrift::TApplicationException& val) {
1058
failure = val;
1059
}
1060
1061
void __set_ire(const InvalidRequestException& val) {
1062
ire = val;
1063
}
1064
1065
void __set_ue(const UnavailableException& val) {
1066
ue = val;
1067
}
1068
1069
void __set_te(const TimedOutException& val) {
1070
te = val;
1071
}
1072
1073
bool operator == (const Cassandra_multiget_slice_result & rhs) const
1074
{
1075
if (!(success == rhs.success))
1076
return false;
1077
if (!(ire == rhs.ire))
1078
return false;
1079
if (!(ue == rhs.ue))
1080
return false;
1081
if (!(te == rhs.te))
1082
return false;
1083
return true;
1084
}
1085
bool operator != (const Cassandra_multiget_slice_result &rhs) const {
1086
return !(*this == rhs);
1087
}
1088
1089
bool operator < (const Cassandra_multiget_slice_result & ) const;
1090
1091
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1092
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1093
1094
};
1095
1096
typedef struct _Cassandra_multiget_slice_presult__isset {
1097
_Cassandra_multiget_slice_presult__isset() : success(false), failure(false), ire(false), ue(false), te(false) {}
1098
bool success;
1099
bool failure;
1100
bool ire;
1101
bool ue;
1102
bool te;
1103
} _Cassandra_multiget_slice_presult__isset;
1104
1105
class Cassandra_multiget_slice_presult {
1106
public:
1107
1108
1109
virtual ~Cassandra_multiget_slice_presult() throw() {}
1110
1111
std::map<std::string, std::vector<ColumnOrSuperColumn> > * success;
1112
apache::thrift::TApplicationException* failure;
1113
InvalidRequestException ire;
1114
UnavailableException ue;
1115
TimedOutException te;
1116
1117
_Cassandra_multiget_slice_presult__isset __isset;
1118
1119
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1120
1121
};
1122
1123
1124
class Cassandra_multiget_count_args {
1125
public:
1126
1127
Cassandra_multiget_count_args() : consistency_level((ConsistencyLevel::type)1) {
1128
consistency_level = (ConsistencyLevel::type)1;
1129
1130
}
1131
1132
virtual ~Cassandra_multiget_count_args() throw() {}
1133
1134
std::vector<std::string> keys;
1135
ColumnParent column_parent;
1136
SlicePredicate predicate;
1137
ConsistencyLevel::type consistency_level;
1138
1139
void __set_keys(const std::vector<std::string> & val) {
1140
keys = val;
1141
}
1142
1143
void __set_column_parent(const ColumnParent& val) {
1144
column_parent = val;
1145
}
1146
1147
void __set_predicate(const SlicePredicate& val) {
1148
predicate = val;
1149
}
1150
1151
void __set_consistency_level(const ConsistencyLevel::type val) {
1152
consistency_level = val;
1153
}
1154
1155
bool operator == (const Cassandra_multiget_count_args & rhs) const
1156
{
1157
if (!(keys == rhs.keys))
1158
return false;
1159
if (!(column_parent == rhs.column_parent))
1160
return false;
1161
if (!(predicate == rhs.predicate))
1162
return false;
1163
if (!(consistency_level == rhs.consistency_level))
1164
return false;
1165
return true;
1166
}
1167
bool operator != (const Cassandra_multiget_count_args &rhs) const {
1168
return !(*this == rhs);
1169
}
1170
1171
bool operator < (const Cassandra_multiget_count_args & ) const;
1172
1173
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1174
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1175
1176
};
1177
1178
1179
class Cassandra_multiget_count_pargs {
1180
public:
1181
1182
1183
virtual ~Cassandra_multiget_count_pargs() throw() {}
1184
1185
const std::vector<std::string> * keys;
1186
const ColumnParent* column_parent;
1187
const SlicePredicate* predicate;
1188
const ConsistencyLevel::type* consistency_level;
1189
1190
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1191
1192
};
1193
1194
typedef struct _Cassandra_multiget_count_result__isset {
1195
_Cassandra_multiget_count_result__isset() : success(false), failure(false), ire(false), ue(false), te(false) {}
1196
bool success;
1197
bool failure;
1198
bool ire;
1199
bool ue;
1200
bool te;
1201
} _Cassandra_multiget_count_result__isset;
1202
1203
class Cassandra_multiget_count_result {
1204
public:
1205
1206
Cassandra_multiget_count_result() {
1207
}
1208
1209
virtual ~Cassandra_multiget_count_result() throw() {}
1210
1211
typedef apache::thrift::TApplicationException failure_t;
1212
typedef const std::map<std::string, int32_t> & success_constref_nonvoid_t;
1213
typedef const std::map<std::string, int32_t> & success_constref_t;
1214
typedef std::map<std::string, int32_t> success_nonvoid_t;
1215
typedef std::map<std::string, int32_t> success_t;
1216
std::map<std::string, int32_t> success;
1217
apache::thrift::TApplicationException failure;
1218
InvalidRequestException ire;
1219
UnavailableException ue;
1220
TimedOutException te;
1221
1222
_Cassandra_multiget_count_result__isset __isset;
1223
1224
void __set_success(const std::map<std::string, int32_t> & val) {
1225
success = val;
1226
}
1227
1228
void __set_failure(const apache::thrift::TApplicationException& val) {
1229
failure = val;
1230
}
1231
1232
void __set_ire(const InvalidRequestException& val) {
1233
ire = val;
1234
}
1235
1236
void __set_ue(const UnavailableException& val) {
1237
ue = val;
1238
}
1239
1240
void __set_te(const TimedOutException& val) {
1241
te = val;
1242
}
1243
1244
bool operator == (const Cassandra_multiget_count_result & rhs) const
1245
{
1246
if (!(success == rhs.success))
1247
return false;
1248
if (!(ire == rhs.ire))
1249
return false;
1250
if (!(ue == rhs.ue))
1251
return false;
1252
if (!(te == rhs.te))
1253
return false;
1254
return true;
1255
}
1256
bool operator != (const Cassandra_multiget_count_result &rhs) const {
1257
return !(*this == rhs);
1258
}
1259
1260
bool operator < (const Cassandra_multiget_count_result & ) const;
1261
1262
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1263
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1264
1265
};
1266
1267
typedef struct _Cassandra_multiget_count_presult__isset {
1268
_Cassandra_multiget_count_presult__isset() : success(false), failure(false), ire(false), ue(false), te(false) {}
1269
bool success;
1270
bool failure;
1271
bool ire;
1272
bool ue;
1273
bool te;
1274
} _Cassandra_multiget_count_presult__isset;
1275
1276
class Cassandra_multiget_count_presult {
1277
public:
1278
1279
1280
virtual ~Cassandra_multiget_count_presult() throw() {}
1281
1282
std::map<std::string, int32_t> * success;
1283
apache::thrift::TApplicationException* failure;
1284
InvalidRequestException ire;
1285
UnavailableException ue;
1286
TimedOutException te;
1287
1288
_Cassandra_multiget_count_presult__isset __isset;
1289
1290
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1291
1292
};
1293
1294
1295
class Cassandra_get_range_slices_args {
1296
public:
1297
1298
Cassandra_get_range_slices_args() : consistency_level((ConsistencyLevel::type)1) {
1299
consistency_level = (ConsistencyLevel::type)1;
1300
1301
}
1302
1303
virtual ~Cassandra_get_range_slices_args() throw() {}
1304
1305
ColumnParent column_parent;
1306
SlicePredicate predicate;
1307
KeyRange range;
1308
ConsistencyLevel::type consistency_level;
1309
1310
void __set_column_parent(const ColumnParent& val) {
1311
column_parent = val;
1312
}
1313
1314
void __set_predicate(const SlicePredicate& val) {
1315
predicate = val;
1316
}
1317
1318
void __set_range(const KeyRange& val) {
1319
range = val;
1320
}
1321
1322
void __set_consistency_level(const ConsistencyLevel::type val) {
1323
consistency_level = val;
1324
}
1325
1326
bool operator == (const Cassandra_get_range_slices_args & rhs) const
1327
{
1328
if (!(column_parent == rhs.column_parent))
1329
return false;
1330
if (!(predicate == rhs.predicate))
1331
return false;
1332
if (!(range == rhs.range))
1333
return false;
1334
if (!(consistency_level == rhs.consistency_level))
1335
return false;
1336
return true;
1337
}
1338
bool operator != (const Cassandra_get_range_slices_args &rhs) const {
1339
return !(*this == rhs);
1340
}
1341
1342
bool operator < (const Cassandra_get_range_slices_args & ) const;
1343
1344
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1345
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1346
1347
};
1348
1349
1350
class Cassandra_get_range_slices_pargs {
1351
public:
1352
1353
1354
virtual ~Cassandra_get_range_slices_pargs() throw() {}
1355
1356
const ColumnParent* column_parent;
1357
const SlicePredicate* predicate;
1358
const KeyRange* range;
1359
const ConsistencyLevel::type* consistency_level;
1360
1361
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1362
1363
};
1364
1365
typedef struct _Cassandra_get_range_slices_result__isset {
1366
_Cassandra_get_range_slices_result__isset() : success(false), failure(false), ire(false), ue(false), te(false) {}
1367
bool success;
1368
bool failure;
1369
bool ire;
1370
bool ue;
1371
bool te;
1372
} _Cassandra_get_range_slices_result__isset;
1373
1374
class Cassandra_get_range_slices_result {
1375
public:
1376
1377
Cassandra_get_range_slices_result() {
1378
}
1379
1380
virtual ~Cassandra_get_range_slices_result() throw() {}
1381
1382
typedef apache::thrift::TApplicationException failure_t;
1383
typedef const std::vector<KeySlice> & success_constref_nonvoid_t;
1384
typedef const std::vector<KeySlice> & success_constref_t;
1385
typedef std::vector<KeySlice> success_nonvoid_t;
1386
typedef std::vector<KeySlice> success_t;
1387
std::vector<KeySlice> success;
1388
apache::thrift::TApplicationException failure;
1389
InvalidRequestException ire;
1390
UnavailableException ue;
1391
TimedOutException te;
1392
1393
_Cassandra_get_range_slices_result__isset __isset;
1394
1395
void __set_success(const std::vector<KeySlice> & val) {
1396
success = val;
1397
}
1398
1399
void __set_failure(const apache::thrift::TApplicationException& val) {
1400
failure = val;
1401
}
1402
1403
void __set_ire(const InvalidRequestException& val) {
1404
ire = val;
1405
}
1406
1407
void __set_ue(const UnavailableException& val) {
1408
ue = val;
1409
}
1410
1411
void __set_te(const TimedOutException& val) {
1412
te = val;
1413
}
1414
1415
bool operator == (const Cassandra_get_range_slices_result & rhs) const
1416
{
1417
if (!(success == rhs.success))
1418
return false;
1419
if (!(ire == rhs.ire))
1420
return false;
1421
if (!(ue == rhs.ue))
1422
return false;
1423
if (!(te == rhs.te))
1424
return false;
1425
return true;
1426
}
1427
bool operator != (const Cassandra_get_range_slices_result &rhs) const {
1428
return !(*this == rhs);
1429
}
1430
1431
bool operator < (const Cassandra_get_range_slices_result & ) const;
1432
1433
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1434
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1435
1436
};
1437
1438
typedef struct _Cassandra_get_range_slices_presult__isset {
1439
_Cassandra_get_range_slices_presult__isset() : success(false), failure(false), ire(false), ue(false), te(false) {}
1440
bool success;
1441
bool failure;
1442
bool ire;
1443
bool ue;
1444
bool te;
1445
} _Cassandra_get_range_slices_presult__isset;
1446
1447
class Cassandra_get_range_slices_presult {
1448
public:
1449
1450
1451
virtual ~Cassandra_get_range_slices_presult() throw() {}
1452
1453
std::vector<KeySlice> * success;
1454
apache::thrift::TApplicationException* failure;
1455
InvalidRequestException ire;
1456
UnavailableException ue;
1457
TimedOutException te;
1458
1459
_Cassandra_get_range_slices_presult__isset __isset;
1460
1461
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1462
1463
};
1464
1465
1466
class Cassandra_get_paged_slice_args {
1467
public:
1468
1469
Cassandra_get_paged_slice_args() : column_family(), start_column(), consistency_level((ConsistencyLevel::type)1) {
1470
consistency_level = (ConsistencyLevel::type)1;
1471
1472
}
1473
1474
virtual ~Cassandra_get_paged_slice_args() throw() {}
1475
1476
std::string column_family;
1477
KeyRange range;
1478
std::string start_column;
1479
ConsistencyLevel::type consistency_level;
1480
1481
void __set_column_family(const std::string& val) {
1482
column_family = val;
1483
}
1484
1485
void __set_range(const KeyRange& val) {
1486
range = val;
1487
}
1488
1489
void __set_start_column(const std::string& val) {
1490
start_column = val;
1491
}
1492
1493
void __set_consistency_level(const ConsistencyLevel::type val) {
1494
consistency_level = val;
1495
}
1496
1497
bool operator == (const Cassandra_get_paged_slice_args & rhs) const
1498
{
1499
if (!(column_family == rhs.column_family))
1500
return false;
1501
if (!(range == rhs.range))
1502
return false;
1503
if (!(start_column == rhs.start_column))
1504
return false;
1505
if (!(consistency_level == rhs.consistency_level))
1506
return false;
1507
return true;
1508
}
1509
bool operator != (const Cassandra_get_paged_slice_args &rhs) const {
1510
return !(*this == rhs);
1511
}
1512
1513
bool operator < (const Cassandra_get_paged_slice_args & ) const;
1514
1515
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1516
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1517
1518
};
1519
1520
1521
class Cassandra_get_paged_slice_pargs {
1522
public:
1523
1524
1525
virtual ~Cassandra_get_paged_slice_pargs() throw() {}
1526
1527
const std::string* column_family;
1528
const KeyRange* range;
1529
const std::string* start_column;
1530
const ConsistencyLevel::type* consistency_level;
1531
1532
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1533
1534
};
1535
1536
typedef struct _Cassandra_get_paged_slice_result__isset {
1537
_Cassandra_get_paged_slice_result__isset() : success(false), failure(false), ire(false), ue(false), te(false) {}
1538
bool success;
1539
bool failure;
1540
bool ire;
1541
bool ue;
1542
bool te;
1543
} _Cassandra_get_paged_slice_result__isset;
1544
1545
class Cassandra_get_paged_slice_result {
1546
public:
1547
1548
Cassandra_get_paged_slice_result() {
1549
}
1550
1551
virtual ~Cassandra_get_paged_slice_result() throw() {}
1552
1553
typedef apache::thrift::TApplicationException failure_t;
1554
typedef const std::vector<KeySlice> & success_constref_nonvoid_t;
1555
typedef const std::vector<KeySlice> & success_constref_t;
1556
typedef std::vector<KeySlice> success_nonvoid_t;
1557
typedef std::vector<KeySlice> success_t;
1558
std::vector<KeySlice> success;
1559
apache::thrift::TApplicationException failure;
1560
InvalidRequestException ire;
1561
UnavailableException ue;
1562
TimedOutException te;
1563
1564
_Cassandra_get_paged_slice_result__isset __isset;
1565
1566
void __set_success(const std::vector<KeySlice> & val) {
1567
success = val;
1568
}
1569
1570
void __set_failure(const apache::thrift::TApplicationException& val) {
1571
failure = val;
1572
}
1573
1574
void __set_ire(const InvalidRequestException& val) {
1575
ire = val;
1576
}
1577
1578
void __set_ue(const UnavailableException& val) {
1579
ue = val;
1580
}
1581
1582
void __set_te(const TimedOutException& val) {
1583
te = val;
1584
}
1585
1586
bool operator == (const Cassandra_get_paged_slice_result & rhs) const
1587
{
1588
if (!(success == rhs.success))
1589
return false;
1590
if (!(ire == rhs.ire))
1591
return false;
1592
if (!(ue == rhs.ue))
1593
return false;
1594
if (!(te == rhs.te))
1595
return false;
1596
return true;
1597
}
1598
bool operator != (const Cassandra_get_paged_slice_result &rhs) const {
1599
return !(*this == rhs);
1600
}
1601
1602
bool operator < (const Cassandra_get_paged_slice_result & ) const;
1603
1604
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1605
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1606
1607
};
1608
1609
typedef struct _Cassandra_get_paged_slice_presult__isset {
1610
_Cassandra_get_paged_slice_presult__isset() : success(false), failure(false), ire(false), ue(false), te(false) {}
1611
bool success;
1612
bool failure;
1613
bool ire;
1614
bool ue;
1615
bool te;
1616
} _Cassandra_get_paged_slice_presult__isset;
1617
1618
class Cassandra_get_paged_slice_presult {
1619
public:
1620
1621
1622
virtual ~Cassandra_get_paged_slice_presult() throw() {}
1623
1624
std::vector<KeySlice> * success;
1625
apache::thrift::TApplicationException* failure;
1626
InvalidRequestException ire;
1627
UnavailableException ue;
1628
TimedOutException te;
1629
1630
_Cassandra_get_paged_slice_presult__isset __isset;
1631
1632
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1633
1634
};
1635
1636
1637
class Cassandra_get_indexed_slices_args {
1638
public:
1639
1640
Cassandra_get_indexed_slices_args() : consistency_level((ConsistencyLevel::type)1) {
1641
consistency_level = (ConsistencyLevel::type)1;
1642
1643
}
1644
1645
virtual ~Cassandra_get_indexed_slices_args() throw() {}
1646
1647
ColumnParent column_parent;
1648
IndexClause index_clause;
1649
SlicePredicate column_predicate;
1650
ConsistencyLevel::type consistency_level;
1651
1652
void __set_column_parent(const ColumnParent& val) {
1653
column_parent = val;
1654
}
1655
1656
void __set_index_clause(const IndexClause& val) {
1657
index_clause = val;
1658
}
1659
1660
void __set_column_predicate(const SlicePredicate& val) {
1661
column_predicate = val;
1662
}
1663
1664
void __set_consistency_level(const ConsistencyLevel::type val) {
1665
consistency_level = val;
1666
}
1667
1668
bool operator == (const Cassandra_get_indexed_slices_args & rhs) const
1669
{
1670
if (!(column_parent == rhs.column_parent))
1671
return false;
1672
if (!(index_clause == rhs.index_clause))
1673
return false;
1674
if (!(column_predicate == rhs.column_predicate))
1675
return false;
1676
if (!(consistency_level == rhs.consistency_level))
1677
return false;
1678
return true;
1679
}
1680
bool operator != (const Cassandra_get_indexed_slices_args &rhs) const {
1681
return !(*this == rhs);
1682
}
1683
1684
bool operator < (const Cassandra_get_indexed_slices_args & ) const;
1685
1686
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1687
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1688
1689
};
1690
1691
1692
class Cassandra_get_indexed_slices_pargs {
1693
public:
1694
1695
1696
virtual ~Cassandra_get_indexed_slices_pargs() throw() {}
1697
1698
const ColumnParent* column_parent;
1699
const IndexClause* index_clause;
1700
const SlicePredicate* column_predicate;
1701
const ConsistencyLevel::type* consistency_level;
1702
1703
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1704
1705
};
1706
1707
typedef struct _Cassandra_get_indexed_slices_result__isset {
1708
_Cassandra_get_indexed_slices_result__isset() : success(false), failure(false), ire(false), ue(false), te(false) {}
1709
bool success;
1710
bool failure;
1711
bool ire;
1712
bool ue;
1713
bool te;
1714
} _Cassandra_get_indexed_slices_result__isset;
1715
1716
class Cassandra_get_indexed_slices_result {
1717
public:
1718
1719
Cassandra_get_indexed_slices_result() {
1720
}
1721
1722
virtual ~Cassandra_get_indexed_slices_result() throw() {}
1723
1724
typedef apache::thrift::TApplicationException failure_t;
1725
typedef const std::vector<KeySlice> & success_constref_nonvoid_t;
1726
typedef const std::vector<KeySlice> & success_constref_t;
1727
typedef std::vector<KeySlice> success_nonvoid_t;
1728
typedef std::vector<KeySlice> success_t;
1729
std::vector<KeySlice> success;
1730
apache::thrift::TApplicationException failure;
1731
InvalidRequestException ire;
1732
UnavailableException ue;
1733
TimedOutException te;
1734
1735
_Cassandra_get_indexed_slices_result__isset __isset;
1736
1737
void __set_success(const std::vector<KeySlice> & val) {
1738
success = val;
1739
}
1740
1741
void __set_failure(const apache::thrift::TApplicationException& val) {
1742
failure = val;
1743
}
1744
1745
void __set_ire(const InvalidRequestException& val) {
1746
ire = val;
1747
}
1748
1749
void __set_ue(const UnavailableException& val) {
1750
ue = val;
1751
}
1752
1753
void __set_te(const TimedOutException& val) {
1754
te = val;
1755
}
1756
1757
bool operator == (const Cassandra_get_indexed_slices_result & rhs) const
1758
{
1759
if (!(success == rhs.success))
1760
return false;
1761
if (!(ire == rhs.ire))
1762
return false;
1763
if (!(ue == rhs.ue))
1764
return false;
1765
if (!(te == rhs.te))
1766
return false;
1767
return true;
1768
}
1769
bool operator != (const Cassandra_get_indexed_slices_result &rhs) const {
1770
return !(*this == rhs);
1771
}
1772
1773
bool operator < (const Cassandra_get_indexed_slices_result & ) const;
1774
1775
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1776
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1777
1778
};
1779
1780
typedef struct _Cassandra_get_indexed_slices_presult__isset {
1781
_Cassandra_get_indexed_slices_presult__isset() : success(false), failure(false), ire(false), ue(false), te(false) {}
1782
bool success;
1783
bool failure;
1784
bool ire;
1785
bool ue;
1786
bool te;
1787
} _Cassandra_get_indexed_slices_presult__isset;
1788
1789
class Cassandra_get_indexed_slices_presult {
1790
public:
1791
1792
1793
virtual ~Cassandra_get_indexed_slices_presult() throw() {}
1794
1795
std::vector<KeySlice> * success;
1796
apache::thrift::TApplicationException* failure;
1797
InvalidRequestException ire;
1798
UnavailableException ue;
1799
TimedOutException te;
1800
1801
_Cassandra_get_indexed_slices_presult__isset __isset;
1802
1803
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1804
1805
};
1806
1807
1808
class Cassandra_insert_args {
1809
public:
1810
1811
Cassandra_insert_args() : key(), consistency_level((ConsistencyLevel::type)1) {
1812
consistency_level = (ConsistencyLevel::type)1;
1813
1814
}
1815
1816
virtual ~Cassandra_insert_args() throw() {}
1817
1818
std::string key;
1819
ColumnParent column_parent;
1820
Column column;
1821
ConsistencyLevel::type consistency_level;
1822
1823
void __set_key(const std::string& val) {
1824
key = val;
1825
}
1826
1827
void __set_column_parent(const ColumnParent& val) {
1828
column_parent = val;
1829
}
1830
1831
void __set_column(const Column& val) {
1832
column = val;
1833
}
1834
1835
void __set_consistency_level(const ConsistencyLevel::type val) {
1836
consistency_level = val;
1837
}
1838
1839
bool operator == (const Cassandra_insert_args & rhs) const
1840
{
1841
if (!(key == rhs.key))
1842
return false;
1843
if (!(column_parent == rhs.column_parent))
1844
return false;
1845
if (!(column == rhs.column))
1846
return false;
1847
if (!(consistency_level == rhs.consistency_level))
1848
return false;
1849
return true;
1850
}
1851
bool operator != (const Cassandra_insert_args &rhs) const {
1852
return !(*this == rhs);
1853
}
1854
1855
bool operator < (const Cassandra_insert_args & ) const;
1856
1857
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1858
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1859
1860
};
1861
1862
1863
class Cassandra_insert_pargs {
1864
public:
1865
1866
1867
virtual ~Cassandra_insert_pargs() throw() {}
1868
1869
const std::string* key;
1870
const ColumnParent* column_parent;
1871
const Column* column;
1872
const ConsistencyLevel::type* consistency_level;
1873
1874
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1875
1876
};
1877
1878
typedef struct _Cassandra_insert_result__isset {
1879
_Cassandra_insert_result__isset() : failure(false), ire(false), ue(false), te(false) {}
1880
bool failure;
1881
bool ire;
1882
bool ue;
1883
bool te;
1884
} _Cassandra_insert_result__isset;
1885
1886
class Cassandra_insert_result {
1887
public:
1888
1889
Cassandra_insert_result() {
1890
}
1891
1892
virtual ~Cassandra_insert_result() throw() {}
1893
1894
typedef apache::thrift::TApplicationException failure_t;
1895
typedef bool success_constref_nonvoid_t;
1896
typedef void success_constref_t;
1897
typedef bool success_nonvoid_t;
1898
typedef void success_t;
1899
apache::thrift::TApplicationException failure;
1900
InvalidRequestException ire;
1901
UnavailableException ue;
1902
TimedOutException te;
1903
1904
_Cassandra_insert_result__isset __isset;
1905
1906
void __set_failure(const apache::thrift::TApplicationException& val) {
1907
failure = val;
1908
}
1909
1910
void __set_ire(const InvalidRequestException& val) {
1911
ire = val;
1912
}
1913
1914
void __set_ue(const UnavailableException& val) {
1915
ue = val;
1916
}
1917
1918
void __set_te(const TimedOutException& val) {
1919
te = val;
1920
}
1921
1922
bool operator == (const Cassandra_insert_result & rhs) const
1923
{
1924
if (!(ire == rhs.ire))
1925
return false;
1926
if (!(ue == rhs.ue))
1927
return false;
1928
if (!(te == rhs.te))
1929
return false;
1930
return true;
1931
}
1932
bool operator != (const Cassandra_insert_result &rhs) const {
1933
return !(*this == rhs);
1934
}
1935
1936
bool operator < (const Cassandra_insert_result & ) const;
1937
1938
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1939
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1940
1941
};
1942
1943
typedef struct _Cassandra_insert_presult__isset {
1944
_Cassandra_insert_presult__isset() : failure(false), ire(false), ue(false), te(false) {}
1945
bool failure;
1946
bool ire;
1947
bool ue;
1948
bool te;
1949
} _Cassandra_insert_presult__isset;
1950
1951
class Cassandra_insert_presult {
1952
public:
1953
1954
1955
virtual ~Cassandra_insert_presult() throw() {}
1956
1957
apache::thrift::TApplicationException* failure;
1958
InvalidRequestException ire;
1959
UnavailableException ue;
1960
TimedOutException te;
1961
1962
_Cassandra_insert_presult__isset __isset;
1963
1964
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1965
1966
};
1967
1968
1969
class Cassandra_add_args {
1970
public:
1971
1972
Cassandra_add_args() : key(), consistency_level((ConsistencyLevel::type)1) {
1973
consistency_level = (ConsistencyLevel::type)1;
1974
1975
}
1976
1977
virtual ~Cassandra_add_args() throw() {}
1978
1979
std::string key;
1980
ColumnParent column_parent;
1981
CounterColumn column;
1982
ConsistencyLevel::type consistency_level;
1983
1984
void __set_key(const std::string& val) {
1985
key = val;
1986
}
1987
1988
void __set_column_parent(const ColumnParent& val) {
1989
column_parent = val;
1990
}
1991
1992
void __set_column(const CounterColumn& val) {
1993
column = val;
1994
}
1995
1996
void __set_consistency_level(const ConsistencyLevel::type val) {
1997
consistency_level = val;
1998
}
1999
2000
bool operator == (const Cassandra_add_args & rhs) const
2001
{
2002
if (!(key == rhs.key))
2003
return false;
2004
if (!(column_parent == rhs.column_parent))
2005
return false;
2006
if (!(column == rhs.column))
2007
return false;
2008
if (!(consistency_level == rhs.consistency_level))
2009
return false;
2010
return true;
2011
}
2012
bool operator != (const Cassandra_add_args &rhs) const {
2013
return !(*this == rhs);
2014
}
2015
2016
bool operator < (const Cassandra_add_args & ) const;
2017
2018
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2019
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2020
2021
};
2022
2023
2024
class Cassandra_add_pargs {
2025
public:
2026
2027
2028
virtual ~Cassandra_add_pargs() throw() {}
2029
2030
const std::string* key;
2031
const ColumnParent* column_parent;
2032
const CounterColumn* column;
2033
const ConsistencyLevel::type* consistency_level;
2034
2035
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2036
2037
};
2038
2039
typedef struct _Cassandra_add_result__isset {
2040
_Cassandra_add_result__isset() : failure(false), ire(false), ue(false), te(false) {}
2041
bool failure;
2042
bool ire;
2043
bool ue;
2044
bool te;
2045
} _Cassandra_add_result__isset;
2046
2047
class Cassandra_add_result {
2048
public:
2049
2050
Cassandra_add_result() {
2051
}
2052
2053
virtual ~Cassandra_add_result() throw() {}
2054
2055
typedef apache::thrift::TApplicationException failure_t;
2056
typedef bool success_constref_nonvoid_t;
2057
typedef void success_constref_t;
2058
typedef bool success_nonvoid_t;
2059
typedef void success_t;
2060
apache::thrift::TApplicationException failure;
2061
InvalidRequestException ire;
2062
UnavailableException ue;
2063
TimedOutException te;
2064
2065
_Cassandra_add_result__isset __isset;
2066
2067
void __set_failure(const apache::thrift::TApplicationException& val) {
2068
failure = val;
2069
}
2070
2071
void __set_ire(const InvalidRequestException& val) {
2072
ire = val;
2073
}
2074
2075
void __set_ue(const UnavailableException& val) {
2076
ue = val;
2077
}
2078
2079
void __set_te(const TimedOutException& val) {
2080
te = val;
2081
}
2082
2083
bool operator == (const Cassandra_add_result & rhs) const
2084
{
2085
if (!(ire == rhs.ire))
2086
return false;
2087
if (!(ue == rhs.ue))
2088
return false;
2089
if (!(te == rhs.te))
2090
return false;
2091
return true;
2092
}
2093
bool operator != (const Cassandra_add_result &rhs) const {
2094
return !(*this == rhs);
2095
}
2096
2097
bool operator < (const Cassandra_add_result & ) const;
2098
2099
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2100
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2101
2102
};
2103
2104
typedef struct _Cassandra_add_presult__isset {
2105
_Cassandra_add_presult__isset() : failure(false), ire(false), ue(false), te(false) {}
2106
bool failure;
2107
bool ire;
2108
bool ue;
2109
bool te;
2110
} _Cassandra_add_presult__isset;
2111
2112
class Cassandra_add_presult {
2113
public:
2114
2115
2116
virtual ~Cassandra_add_presult() throw() {}
2117
2118
apache::thrift::TApplicationException* failure;
2119
InvalidRequestException ire;
2120
UnavailableException ue;
2121
TimedOutException te;
2122
2123
_Cassandra_add_presult__isset __isset;
2124
2125
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2126
2127
};
2128
2129
typedef struct _Cassandra_remove_args__isset {
2130
_Cassandra_remove_args__isset() : consistency_level(true) {}
2131
bool consistency_level;
2132
} _Cassandra_remove_args__isset;
2133
2134
class Cassandra_remove_args {
2135
public:
2136
2137
Cassandra_remove_args() : key(), timestamp(0), consistency_level((ConsistencyLevel::type)1) {
2138
consistency_level = (ConsistencyLevel::type)1;
2139
2140
}
2141
2142
virtual ~Cassandra_remove_args() throw() {}
2143
2144
std::string key;
2145
ColumnPath column_path;
2146
int64_t timestamp;
2147
ConsistencyLevel::type consistency_level;
2148
2149
_Cassandra_remove_args__isset __isset;
2150
2151
void __set_key(const std::string& val) {
2152
key = val;
2153
}
2154
2155
void __set_column_path(const ColumnPath& val) {
2156
column_path = val;
2157
}
2158
2159
void __set_timestamp(const int64_t val) {
2160
timestamp = val;
2161
}
2162
2163
void __set_consistency_level(const ConsistencyLevel::type val) {
2164
consistency_level = val;
2165
}
2166
2167
bool operator == (const Cassandra_remove_args & rhs) const
2168
{
2169
if (!(key == rhs.key))
2170
return false;
2171
if (!(column_path == rhs.column_path))
2172
return false;
2173
if (!(timestamp == rhs.timestamp))
2174
return false;
2175
if (!(consistency_level == rhs.consistency_level))
2176
return false;
2177
return true;
2178
}
2179
bool operator != (const Cassandra_remove_args &rhs) const {
2180
return !(*this == rhs);
2181
}
2182
2183
bool operator < (const Cassandra_remove_args & ) const;
2184
2185
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2186
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2187
2188
};
2189
2190
2191
class Cassandra_remove_pargs {
2192
public:
2193
2194
2195
virtual ~Cassandra_remove_pargs() throw() {}
2196
2197
const std::string* key;
2198
const ColumnPath* column_path;
2199
const int64_t* timestamp;
2200
const ConsistencyLevel::type* consistency_level;
2201
2202
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2203
2204
};
2205
2206
typedef struct _Cassandra_remove_result__isset {
2207
_Cassandra_remove_result__isset() : failure(false), ire(false), ue(false), te(false) {}
2208
bool failure;
2209
bool ire;
2210
bool ue;
2211
bool te;
2212
} _Cassandra_remove_result__isset;
2213
2214
class Cassandra_remove_result {
2215
public:
2216
2217
Cassandra_remove_result() {
2218
}
2219
2220
virtual ~Cassandra_remove_result() throw() {}
2221
2222
typedef apache::thrift::TApplicationException failure_t;
2223
typedef bool success_constref_nonvoid_t;
2224
typedef void success_constref_t;
2225
typedef bool success_nonvoid_t;
2226
typedef void success_t;
2227
apache::thrift::TApplicationException failure;
2228
InvalidRequestException ire;
2229
UnavailableException ue;
2230
TimedOutException te;
2231
2232
_Cassandra_remove_result__isset __isset;
2233
2234
void __set_failure(const apache::thrift::TApplicationException& val) {
2235
failure = val;
2236
}
2237
2238
void __set_ire(const InvalidRequestException& val) {
2239
ire = val;
2240
}
2241
2242
void __set_ue(const UnavailableException& val) {
2243
ue = val;
2244
}
2245
2246
void __set_te(const TimedOutException& val) {
2247
te = val;
2248
}
2249
2250
bool operator == (const Cassandra_remove_result & rhs) const
2251
{
2252
if (!(ire == rhs.ire))
2253
return false;
2254
if (!(ue == rhs.ue))
2255
return false;
2256
if (!(te == rhs.te))
2257
return false;
2258
return true;
2259
}
2260
bool operator != (const Cassandra_remove_result &rhs) const {
2261
return !(*this == rhs);
2262
}
2263
2264
bool operator < (const Cassandra_remove_result & ) const;
2265
2266
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2267
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2268
2269
};
2270
2271
typedef struct _Cassandra_remove_presult__isset {
2272
_Cassandra_remove_presult__isset() : failure(false), ire(false), ue(false), te(false) {}
2273
bool failure;
2274
bool ire;
2275
bool ue;
2276
bool te;
2277
} _Cassandra_remove_presult__isset;
2278
2279
class Cassandra_remove_presult {
2280
public:
2281
2282
2283
virtual ~Cassandra_remove_presult() throw() {}
2284
2285
apache::thrift::TApplicationException* failure;
2286
InvalidRequestException ire;
2287
UnavailableException ue;
2288
TimedOutException te;
2289
2290
_Cassandra_remove_presult__isset __isset;
2291
2292
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2293
2294
};
2295
2296
2297
class Cassandra_remove_counter_args {
2298
public:
2299
2300
Cassandra_remove_counter_args() : key(), consistency_level((ConsistencyLevel::type)1) {
2301
consistency_level = (ConsistencyLevel::type)1;
2302
2303
}
2304
2305
virtual ~Cassandra_remove_counter_args() throw() {}
2306
2307
std::string key;
2308
ColumnPath path;
2309
ConsistencyLevel::type consistency_level;
2310
2311
void __set_key(const std::string& val) {
2312
key = val;
2313
}
2314
2315
void __set_path(const ColumnPath& val) {
2316
path = val;
2317
}
2318
2319
void __set_consistency_level(const ConsistencyLevel::type val) {
2320
consistency_level = val;
2321
}
2322
2323
bool operator == (const Cassandra_remove_counter_args & rhs) const
2324
{
2325
if (!(key == rhs.key))
2326
return false;
2327
if (!(path == rhs.path))
2328
return false;
2329
if (!(consistency_level == rhs.consistency_level))
2330
return false;
2331
return true;
2332
}
2333
bool operator != (const Cassandra_remove_counter_args &rhs) const {
2334
return !(*this == rhs);
2335
}
2336
2337
bool operator < (const Cassandra_remove_counter_args & ) const;
2338
2339
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2340
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2341
2342
};
2343
2344
2345
class Cassandra_remove_counter_pargs {
2346
public:
2347
2348
2349
virtual ~Cassandra_remove_counter_pargs() throw() {}
2350
2351
const std::string* key;
2352
const ColumnPath* path;
2353
const ConsistencyLevel::type* consistency_level;
2354
2355
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2356
2357
};
2358
2359
typedef struct _Cassandra_remove_counter_result__isset {
2360
_Cassandra_remove_counter_result__isset() : failure(false), ire(false), ue(false), te(false) {}
2361
bool failure;
2362
bool ire;
2363
bool ue;
2364
bool te;
2365
} _Cassandra_remove_counter_result__isset;
2366
2367
class Cassandra_remove_counter_result {
2368
public:
2369
2370
Cassandra_remove_counter_result() {
2371
}
2372
2373
virtual ~Cassandra_remove_counter_result() throw() {}
2374
2375
typedef apache::thrift::TApplicationException failure_t;
2376
typedef bool success_constref_nonvoid_t;
2377
typedef void success_constref_t;
2378
typedef bool success_nonvoid_t;
2379
typedef void success_t;
2380
apache::thrift::TApplicationException failure;
2381
InvalidRequestException ire;
2382
UnavailableException ue;
2383
TimedOutException te;
2384
2385
_Cassandra_remove_counter_result__isset __isset;
2386
2387
void __set_failure(const apache::thrift::TApplicationException& val) {
2388
failure = val;
2389
}
2390
2391
void __set_ire(const InvalidRequestException& val) {
2392
ire = val;
2393
}
2394
2395
void __set_ue(const UnavailableException& val) {
2396
ue = val;
2397
}
2398
2399
void __set_te(const TimedOutException& val) {
2400
te = val;
2401
}
2402
2403
bool operator == (const Cassandra_remove_counter_result & rhs) const
2404
{
2405
if (!(ire == rhs.ire))
2406
return false;
2407
if (!(ue == rhs.ue))
2408
return false;
2409
if (!(te == rhs.te))
2410
return false;
2411
return true;
2412
}
2413
bool operator != (const Cassandra_remove_counter_result &rhs) const {
2414
return !(*this == rhs);
2415
}
2416
2417
bool operator < (const Cassandra_remove_counter_result & ) const;
2418
2419
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2420
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2421
2422
};
2423
2424
typedef struct _Cassandra_remove_counter_presult__isset {
2425
_Cassandra_remove_counter_presult__isset() : failure(false), ire(false), ue(false), te(false) {}
2426
bool failure;
2427
bool ire;
2428
bool ue;
2429
bool te;
2430
} _Cassandra_remove_counter_presult__isset;
2431
2432
class Cassandra_remove_counter_presult {
2433
public:
2434
2435
2436
virtual ~Cassandra_remove_counter_presult() throw() {}
2437
2438
apache::thrift::TApplicationException* failure;
2439
InvalidRequestException ire;
2440
UnavailableException ue;
2441
TimedOutException te;
2442
2443
_Cassandra_remove_counter_presult__isset __isset;
2444
2445
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2446
2447
};
2448
2449
2450
class Cassandra_batch_mutate_args {
2451
public:
2452
2453
Cassandra_batch_mutate_args() : consistency_level((ConsistencyLevel::type)1) {
2454
consistency_level = (ConsistencyLevel::type)1;
2455
2456
}
2457
2458
virtual ~Cassandra_batch_mutate_args() throw() {}
2459
2460
std::map<std::string, std::map<std::string, std::vector<Mutation> > > mutation_map;
2461
ConsistencyLevel::type consistency_level;
2462
2463
void __set_mutation_map(const std::map<std::string, std::map<std::string, std::vector<Mutation> > > & val) {
2464
mutation_map = val;
2465
}
2466
2467
void __set_consistency_level(const ConsistencyLevel::type val) {
2468
consistency_level = val;
2469
}
2470
2471
bool operator == (const Cassandra_batch_mutate_args & rhs) const
2472
{
2473
if (!(mutation_map == rhs.mutation_map))
2474
return false;
2475
if (!(consistency_level == rhs.consistency_level))
2476
return false;
2477
return true;
2478
}
2479
bool operator != (const Cassandra_batch_mutate_args &rhs) const {
2480
return !(*this == rhs);
2481
}
2482
2483
bool operator < (const Cassandra_batch_mutate_args & ) const;
2484
2485
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2486
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2487
2488
};
2489
2490
2491
class Cassandra_batch_mutate_pargs {
2492
public:
2493
2494
2495
virtual ~Cassandra_batch_mutate_pargs() throw() {}
2496
2497
const std::map<std::string, std::map<std::string, std::vector<Mutation> > > * mutation_map;
2498
const ConsistencyLevel::type* consistency_level;
2499
2500
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2501
2502
};
2503
2504
typedef struct _Cassandra_batch_mutate_result__isset {
2505
_Cassandra_batch_mutate_result__isset() : failure(false), ire(false), ue(false), te(false) {}
2506
bool failure;
2507
bool ire;
2508
bool ue;
2509
bool te;
2510
} _Cassandra_batch_mutate_result__isset;
2511
2512
class Cassandra_batch_mutate_result {
2513
public:
2514
2515
Cassandra_batch_mutate_result() {
2516
}
2517
2518
virtual ~Cassandra_batch_mutate_result() throw() {}
2519
2520
typedef apache::thrift::TApplicationException failure_t;
2521
typedef bool success_constref_nonvoid_t;
2522
typedef void success_constref_t;
2523
typedef bool success_nonvoid_t;
2524
typedef void success_t;
2525
apache::thrift::TApplicationException failure;
2526
InvalidRequestException ire;
2527
UnavailableException ue;
2528
TimedOutException te;
2529
2530
_Cassandra_batch_mutate_result__isset __isset;
2531
2532
void __set_failure(const apache::thrift::TApplicationException& val) {
2533
failure = val;
2534
}
2535
2536
void __set_ire(const InvalidRequestException& val) {
2537
ire = val;
2538
}
2539
2540
void __set_ue(const UnavailableException& val) {
2541
ue = val;
2542
}
2543
2544
void __set_te(const TimedOutException& val) {
2545
te = val;
2546
}
2547
2548
bool operator == (const Cassandra_batch_mutate_result & rhs) const
2549
{
2550
if (!(ire == rhs.ire))
2551
return false;
2552
if (!(ue == rhs.ue))
2553
return false;
2554
if (!(te == rhs.te))
2555
return false;
2556
return true;
2557
}
2558
bool operator != (const Cassandra_batch_mutate_result &rhs) const {
2559
return !(*this == rhs);
2560
}
2561
2562
bool operator < (const Cassandra_batch_mutate_result & ) const;
2563
2564
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2565
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2566
2567
};
2568
2569
typedef struct _Cassandra_batch_mutate_presult__isset {
2570
_Cassandra_batch_mutate_presult__isset() : failure(false), ire(false), ue(false), te(false) {}
2571
bool failure;
2572
bool ire;
2573
bool ue;
2574
bool te;
2575
} _Cassandra_batch_mutate_presult__isset;
2576
2577
class Cassandra_batch_mutate_presult {
2578
public:
2579
2580
2581
virtual ~Cassandra_batch_mutate_presult() throw() {}
2582
2583
apache::thrift::TApplicationException* failure;
2584
InvalidRequestException ire;
2585
UnavailableException ue;
2586
TimedOutException te;
2587
2588
_Cassandra_batch_mutate_presult__isset __isset;
2589
2590
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2591
2592
};
2593
2594
2595
class Cassandra_truncate_args {
2596
public:
2597
2598
Cassandra_truncate_args() : cfname() {
2599
}
2600
2601
virtual ~Cassandra_truncate_args() throw() {}
2602
2603
std::string cfname;
2604
2605
void __set_cfname(const std::string& val) {
2606
cfname = val;
2607
}
2608
2609
bool operator == (const Cassandra_truncate_args & rhs) const
2610
{
2611
if (!(cfname == rhs.cfname))
2612
return false;
2613
return true;
2614
}
2615
bool operator != (const Cassandra_truncate_args &rhs) const {
2616
return !(*this == rhs);
2617
}
2618
2619
bool operator < (const Cassandra_truncate_args & ) const;
2620
2621
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2622
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2623
2624
};
2625
2626
2627
class Cassandra_truncate_pargs {
2628
public:
2629
2630
2631
virtual ~Cassandra_truncate_pargs() throw() {}
2632
2633
const std::string* cfname;
2634
2635
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2636
2637
};
2638
2639
typedef struct _Cassandra_truncate_result__isset {
2640
_Cassandra_truncate_result__isset() : failure(false), ire(false), ue(false), te(false) {}
2641
bool failure;
2642
bool ire;
2643
bool ue;
2644
bool te;
2645
} _Cassandra_truncate_result__isset;
2646
2647
class Cassandra_truncate_result {
2648
public:
2649
2650
Cassandra_truncate_result() {
2651
}
2652
2653
virtual ~Cassandra_truncate_result() throw() {}
2654
2655
typedef apache::thrift::TApplicationException failure_t;
2656
typedef bool success_constref_nonvoid_t;
2657
typedef void success_constref_t;
2658
typedef bool success_nonvoid_t;
2659
typedef void success_t;
2660
apache::thrift::TApplicationException failure;
2661
InvalidRequestException ire;
2662
UnavailableException ue;
2663
TimedOutException te;
2664
2665
_Cassandra_truncate_result__isset __isset;
2666
2667
void __set_failure(const apache::thrift::TApplicationException& val) {
2668
failure = val;
2669
}
2670
2671
void __set_ire(const InvalidRequestException& val) {
2672
ire = val;
2673
}
2674
2675
void __set_ue(const UnavailableException& val) {
2676
ue = val;
2677
}
2678
2679
void __set_te(const TimedOutException& val) {
2680
te = val;
2681
}
2682
2683
bool operator == (const Cassandra_truncate_result & rhs) const
2684
{
2685
if (!(ire == rhs.ire))
2686
return false;
2687
if (!(ue == rhs.ue))
2688
return false;
2689
if (!(te == rhs.te))
2690
return false;
2691
return true;
2692
}
2693
bool operator != (const Cassandra_truncate_result &rhs) const {
2694
return !(*this == rhs);
2695
}
2696
2697
bool operator < (const Cassandra_truncate_result & ) const;
2698
2699
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2700
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2701
2702
};
2703
2704
typedef struct _Cassandra_truncate_presult__isset {
2705
_Cassandra_truncate_presult__isset() : failure(false), ire(false), ue(false), te(false) {}
2706
bool failure;
2707
bool ire;
2708
bool ue;
2709
bool te;
2710
} _Cassandra_truncate_presult__isset;
2711
2712
class Cassandra_truncate_presult {
2713
public:
2714
2715
2716
virtual ~Cassandra_truncate_presult() throw() {}
2717
2718
apache::thrift::TApplicationException* failure;
2719
InvalidRequestException ire;
2720
UnavailableException ue;
2721
TimedOutException te;
2722
2723
_Cassandra_truncate_presult__isset __isset;
2724
2725
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2726
2727
};
2728
2729
2730
class Cassandra_describe_schema_versions_args {
2731
public:
2732
2733
Cassandra_describe_schema_versions_args() {
2734
}
2735
2736
virtual ~Cassandra_describe_schema_versions_args() throw() {}
2737
2738
2739
bool operator == (const Cassandra_describe_schema_versions_args & /* rhs */) const
2740
{
2741
return true;
2742
}
2743
bool operator != (const Cassandra_describe_schema_versions_args &rhs) const {
2744
return !(*this == rhs);
2745
}
2746
2747
bool operator < (const Cassandra_describe_schema_versions_args & ) const;
2748
2749
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2750
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2751
2752
};
2753
2754
2755
class Cassandra_describe_schema_versions_pargs {
2756
public:
2757
2758
2759
virtual ~Cassandra_describe_schema_versions_pargs() throw() {}
2760
2761
2762
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2763
2764
};
2765
2766
typedef struct _Cassandra_describe_schema_versions_result__isset {
2767
_Cassandra_describe_schema_versions_result__isset() : success(false), failure(false), ire(false) {}
2768
bool success;
2769
bool failure;
2770
bool ire;
2771
} _Cassandra_describe_schema_versions_result__isset;
2772
2773
class Cassandra_describe_schema_versions_result {
2774
public:
2775
2776
Cassandra_describe_schema_versions_result() {
2777
}
2778
2779
virtual ~Cassandra_describe_schema_versions_result() throw() {}
2780
2781
typedef apache::thrift::TApplicationException failure_t;
2782
typedef const std::map<std::string, std::vector<std::string> > & success_constref_nonvoid_t;
2783
typedef const std::map<std::string, std::vector<std::string> > & success_constref_t;
2784
typedef std::map<std::string, std::vector<std::string> > success_nonvoid_t;
2785
typedef std::map<std::string, std::vector<std::string> > success_t;
2786
std::map<std::string, std::vector<std::string> > success;
2787
apache::thrift::TApplicationException failure;
2788
InvalidRequestException ire;
2789
2790
_Cassandra_describe_schema_versions_result__isset __isset;
2791
2792
void __set_success(const std::map<std::string, std::vector<std::string> > & val) {
2793
success = val;
2794
}
2795
2796
void __set_failure(const apache::thrift::TApplicationException& val) {
2797
failure = val;
2798
}
2799
2800
void __set_ire(const InvalidRequestException& val) {
2801
ire = val;
2802
}
2803
2804
bool operator == (const Cassandra_describe_schema_versions_result & rhs) const
2805
{
2806
if (!(success == rhs.success))
2807
return false;
2808
if (!(ire == rhs.ire))
2809
return false;
2810
return true;
2811
}
2812
bool operator != (const Cassandra_describe_schema_versions_result &rhs) const {
2813
return !(*this == rhs);
2814
}
2815
2816
bool operator < (const Cassandra_describe_schema_versions_result & ) const;
2817
2818
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2819
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2820
2821
};
2822
2823
typedef struct _Cassandra_describe_schema_versions_presult__isset {
2824
_Cassandra_describe_schema_versions_presult__isset() : success(false), failure(false), ire(false) {}
2825
bool success;
2826
bool failure;
2827
bool ire;
2828
} _Cassandra_describe_schema_versions_presult__isset;
2829
2830
class Cassandra_describe_schema_versions_presult {
2831
public:
2832
2833
2834
virtual ~Cassandra_describe_schema_versions_presult() throw() {}
2835
2836
std::map<std::string, std::vector<std::string> > * success;
2837
apache::thrift::TApplicationException* failure;
2838
InvalidRequestException ire;
2839
2840
_Cassandra_describe_schema_versions_presult__isset __isset;
2841
2842
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2843
2844
};
2845
2846
2847
class Cassandra_describe_keyspaces_args {
2848
public:
2849
2850
Cassandra_describe_keyspaces_args() {
2851
}
2852
2853
virtual ~Cassandra_describe_keyspaces_args() throw() {}
2854
2855
2856
bool operator == (const Cassandra_describe_keyspaces_args & /* rhs */) const
2857
{
2858
return true;
2859
}
2860
bool operator != (const Cassandra_describe_keyspaces_args &rhs) const {
2861
return !(*this == rhs);
2862
}
2863
2864
bool operator < (const Cassandra_describe_keyspaces_args & ) const;
2865
2866
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2867
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2868
2869
};
2870
2871
2872
class Cassandra_describe_keyspaces_pargs {
2873
public:
2874
2875
2876
virtual ~Cassandra_describe_keyspaces_pargs() throw() {}
2877
2878
2879
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2880
2881
};
2882
2883
typedef struct _Cassandra_describe_keyspaces_result__isset {
2884
_Cassandra_describe_keyspaces_result__isset() : success(false), failure(false), ire(false) {}
2885
bool success;
2886
bool failure;
2887
bool ire;
2888
} _Cassandra_describe_keyspaces_result__isset;
2889
2890
class Cassandra_describe_keyspaces_result {
2891
public:
2892
2893
Cassandra_describe_keyspaces_result() {
2894
}
2895
2896
virtual ~Cassandra_describe_keyspaces_result() throw() {}
2897
2898
typedef apache::thrift::TApplicationException failure_t;
2899
typedef const std::vector<KsDef> & success_constref_nonvoid_t;
2900
typedef const std::vector<KsDef> & success_constref_t;
2901
typedef std::vector<KsDef> success_nonvoid_t;
2902
typedef std::vector<KsDef> success_t;
2903
std::vector<KsDef> success;
2904
apache::thrift::TApplicationException failure;
2905
InvalidRequestException ire;
2906
2907
_Cassandra_describe_keyspaces_result__isset __isset;
2908
2909
void __set_success(const std::vector<KsDef> & val) {
2910
success = val;
2911
}
2912
2913
void __set_failure(const apache::thrift::TApplicationException& val) {
2914
failure = val;
2915
}
2916
2917
void __set_ire(const InvalidRequestException& val) {
2918
ire = val;
2919
}
2920
2921
bool operator == (const Cassandra_describe_keyspaces_result & rhs) const
2922
{
2923
if (!(success == rhs.success))
2924
return false;
2925
if (!(ire == rhs.ire))
2926
return false;
2927
return true;
2928
}
2929
bool operator != (const Cassandra_describe_keyspaces_result &rhs) const {
2930
return !(*this == rhs);
2931
}
2932
2933
bool operator < (const Cassandra_describe_keyspaces_result & ) const;
2934
2935
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2936
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2937
2938
};
2939
2940
typedef struct _Cassandra_describe_keyspaces_presult__isset {
2941
_Cassandra_describe_keyspaces_presult__isset() : success(false), failure(false), ire(false) {}
2942
bool success;
2943
bool failure;
2944
bool ire;
2945
} _Cassandra_describe_keyspaces_presult__isset;
2946
2947
class Cassandra_describe_keyspaces_presult {
2948
public:
2949
2950
2951
virtual ~Cassandra_describe_keyspaces_presult() throw() {}
2952
2953
std::vector<KsDef> * success;
2954
apache::thrift::TApplicationException* failure;
2955
InvalidRequestException ire;
2956
2957
_Cassandra_describe_keyspaces_presult__isset __isset;
2958
2959
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2960
2961
};
2962
2963
2964
class Cassandra_describe_cluster_name_args {
2965
public:
2966
2967
Cassandra_describe_cluster_name_args() {
2968
}
2969
2970
virtual ~Cassandra_describe_cluster_name_args() throw() {}
2971
2972
2973
bool operator == (const Cassandra_describe_cluster_name_args & /* rhs */) const
2974
{
2975
return true;
2976
}
2977
bool operator != (const Cassandra_describe_cluster_name_args &rhs) const {
2978
return !(*this == rhs);
2979
}
2980
2981
bool operator < (const Cassandra_describe_cluster_name_args & ) const;
2982
2983
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2984
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2985
2986
};
2987
2988
2989
class Cassandra_describe_cluster_name_pargs {
2990
public:
2991
2992
2993
virtual ~Cassandra_describe_cluster_name_pargs() throw() {}
2994
2995
2996
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2997
2998
};
2999
3000
typedef struct _Cassandra_describe_cluster_name_result__isset {
3001
_Cassandra_describe_cluster_name_result__isset() : success(false), failure(false) {}
3002
bool success;
3003
bool failure;
3004
} _Cassandra_describe_cluster_name_result__isset;
3005
3006
class Cassandra_describe_cluster_name_result {
3007
public:
3008
3009
Cassandra_describe_cluster_name_result() : success() {
3010
}
3011
3012
virtual ~Cassandra_describe_cluster_name_result() throw() {}
3013
3014
typedef apache::thrift::TApplicationException failure_t;
3015
typedef const std::string& success_constref_nonvoid_t;
3016
typedef const std::string& success_constref_t;
3017
typedef std::string success_nonvoid_t;
3018
typedef std::string success_t;
3019
std::string success;
3020
apache::thrift::TApplicationException failure;
3021
3022
_Cassandra_describe_cluster_name_result__isset __isset;
3023
3024
void __set_success(const std::string& val) {
3025
success = val;
3026
}
3027
3028
void __set_failure(const apache::thrift::TApplicationException& val) {
3029
failure = val;
3030
}
3031
3032
bool operator == (const Cassandra_describe_cluster_name_result & rhs) const
3033
{
3034
if (!(success == rhs.success))
3035
return false;
3036
return true;
3037
}
3038
bool operator != (const Cassandra_describe_cluster_name_result &rhs) const {
3039
return !(*this == rhs);
3040
}
3041
3042
bool operator < (const Cassandra_describe_cluster_name_result & ) const;
3043
3044
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3045
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3046
3047
};
3048
3049
typedef struct _Cassandra_describe_cluster_name_presult__isset {
3050
_Cassandra_describe_cluster_name_presult__isset() : success(false), failure(false) {}
3051
bool success;
3052
bool failure;
3053
} _Cassandra_describe_cluster_name_presult__isset;
3054
3055
class Cassandra_describe_cluster_name_presult {
3056
public:
3057
3058
3059
virtual ~Cassandra_describe_cluster_name_presult() throw() {}
3060
3061
std::string* success;
3062
apache::thrift::TApplicationException* failure;
3063
3064
_Cassandra_describe_cluster_name_presult__isset __isset;
3065
3066
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3067
3068
};
3069
3070
3071
class Cassandra_describe_version_args {
3072
public:
3073
3074
Cassandra_describe_version_args() {
3075
}
3076
3077
virtual ~Cassandra_describe_version_args() throw() {}
3078
3079
3080
bool operator == (const Cassandra_describe_version_args & /* rhs */) const
3081
{
3082
return true;
3083
}
3084
bool operator != (const Cassandra_describe_version_args &rhs) const {
3085
return !(*this == rhs);
3086
}
3087
3088
bool operator < (const Cassandra_describe_version_args & ) const;
3089
3090
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3091
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3092
3093
};
3094
3095
3096
class Cassandra_describe_version_pargs {
3097
public:
3098
3099
3100
virtual ~Cassandra_describe_version_pargs() throw() {}
3101
3102
3103
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3104
3105
};
3106
3107
typedef struct _Cassandra_describe_version_result__isset {
3108
_Cassandra_describe_version_result__isset() : success(false), failure(false) {}
3109
bool success;
3110
bool failure;
3111
} _Cassandra_describe_version_result__isset;
3112
3113
class Cassandra_describe_version_result {
3114
public:
3115
3116
Cassandra_describe_version_result() : success() {
3117
}
3118
3119
virtual ~Cassandra_describe_version_result() throw() {}
3120
3121
typedef apache::thrift::TApplicationException failure_t;
3122
typedef const std::string& success_constref_nonvoid_t;
3123
typedef const std::string& success_constref_t;
3124
typedef std::string success_nonvoid_t;
3125
typedef std::string success_t;
3126
std::string success;
3127
apache::thrift::TApplicationException failure;
3128
3129
_Cassandra_describe_version_result__isset __isset;
3130
3131
void __set_success(const std::string& val) {
3132
success = val;
3133
}
3134
3135
void __set_failure(const apache::thrift::TApplicationException& val) {
3136
failure = val;
3137
}
3138
3139
bool operator == (const Cassandra_describe_version_result & rhs) const
3140
{
3141
if (!(success == rhs.success))
3142
return false;
3143
return true;
3144
}
3145
bool operator != (const Cassandra_describe_version_result &rhs) const {
3146
return !(*this == rhs);
3147
}
3148
3149
bool operator < (const Cassandra_describe_version_result & ) const;
3150
3151
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3152
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3153
3154
};
3155
3156
typedef struct _Cassandra_describe_version_presult__isset {
3157
_Cassandra_describe_version_presult__isset() : success(false), failure(false) {}
3158
bool success;
3159
bool failure;
3160
} _Cassandra_describe_version_presult__isset;
3161
3162
class Cassandra_describe_version_presult {
3163
public:
3164
3165
3166
virtual ~Cassandra_describe_version_presult() throw() {}
3167
3168
std::string* success;
3169
apache::thrift::TApplicationException* failure;
3170
3171
_Cassandra_describe_version_presult__isset __isset;
3172
3173
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3174
3175
};
3176
3177
3178
class Cassandra_describe_ring_args {
3179
public:
3180
3181
Cassandra_describe_ring_args() : keyspace() {
3182
}
3183
3184
virtual ~Cassandra_describe_ring_args() throw() {}
3185
3186
std::string keyspace;
3187
3188
void __set_keyspace(const std::string& val) {
3189
keyspace = val;
3190
}
3191
3192
bool operator == (const Cassandra_describe_ring_args & rhs) const
3193
{
3194
if (!(keyspace == rhs.keyspace))
3195
return false;
3196
return true;
3197
}
3198
bool operator != (const Cassandra_describe_ring_args &rhs) const {
3199
return !(*this == rhs);
3200
}
3201
3202
bool operator < (const Cassandra_describe_ring_args & ) const;
3203
3204
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3205
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3206
3207
};
3208
3209
3210
class Cassandra_describe_ring_pargs {
3211
public:
3212
3213
3214
virtual ~Cassandra_describe_ring_pargs() throw() {}
3215
3216
const std::string* keyspace;
3217
3218
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3219
3220
};
3221
3222
typedef struct _Cassandra_describe_ring_result__isset {
3223
_Cassandra_describe_ring_result__isset() : success(false), failure(false), ire(false) {}
3224
bool success;
3225
bool failure;
3226
bool ire;
3227
} _Cassandra_describe_ring_result__isset;
3228
3229
class Cassandra_describe_ring_result {
3230
public:
3231
3232
Cassandra_describe_ring_result() {
3233
}
3234
3235
virtual ~Cassandra_describe_ring_result() throw() {}
3236
3237
typedef apache::thrift::TApplicationException failure_t;
3238
typedef const std::vector<TokenRange> & success_constref_nonvoid_t;
3239
typedef const std::vector<TokenRange> & success_constref_t;
3240
typedef std::vector<TokenRange> success_nonvoid_t;
3241
typedef std::vector<TokenRange> success_t;
3242
std::vector<TokenRange> success;
3243
apache::thrift::TApplicationException failure;
3244
InvalidRequestException ire;
3245
3246
_Cassandra_describe_ring_result__isset __isset;
3247
3248
void __set_success(const std::vector<TokenRange> & val) {
3249
success = val;
3250
}
3251
3252
void __set_failure(const apache::thrift::TApplicationException& val) {
3253
failure = val;
3254
}
3255
3256
void __set_ire(const InvalidRequestException& val) {
3257
ire = val;
3258
}
3259
3260
bool operator == (const Cassandra_describe_ring_result & rhs) const
3261
{
3262
if (!(success == rhs.success))
3263
return false;
3264
if (!(ire == rhs.ire))
3265
return false;
3266
return true;
3267
}
3268
bool operator != (const Cassandra_describe_ring_result &rhs) const {
3269
return !(*this == rhs);
3270
}
3271
3272
bool operator < (const Cassandra_describe_ring_result & ) const;
3273
3274
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3275
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3276
3277
};
3278
3279
typedef struct _Cassandra_describe_ring_presult__isset {
3280
_Cassandra_describe_ring_presult__isset() : success(false), failure(false), ire(false) {}
3281
bool success;
3282
bool failure;
3283
bool ire;
3284
} _Cassandra_describe_ring_presult__isset;
3285
3286
class Cassandra_describe_ring_presult {
3287
public:
3288
3289
3290
virtual ~Cassandra_describe_ring_presult() throw() {}
3291
3292
std::vector<TokenRange> * success;
3293
apache::thrift::TApplicationException* failure;
3294
InvalidRequestException ire;
3295
3296
_Cassandra_describe_ring_presult__isset __isset;
3297
3298
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3299
3300
};
3301
3302
3303
class Cassandra_describe_token_map_args {
3304
public:
3305
3306
Cassandra_describe_token_map_args() {
3307
}
3308
3309
virtual ~Cassandra_describe_token_map_args() throw() {}
3310
3311
3312
bool operator == (const Cassandra_describe_token_map_args & /* rhs */) const
3313
{
3314
return true;
3315
}
3316
bool operator != (const Cassandra_describe_token_map_args &rhs) const {
3317
return !(*this == rhs);
3318
}
3319
3320
bool operator < (const Cassandra_describe_token_map_args & ) const;
3321
3322
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3323
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3324
3325
};
3326
3327
3328
class Cassandra_describe_token_map_pargs {
3329
public:
3330
3331
3332
virtual ~Cassandra_describe_token_map_pargs() throw() {}
3333
3334
3335
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3336
3337
};
3338
3339
typedef struct _Cassandra_describe_token_map_result__isset {
3340
_Cassandra_describe_token_map_result__isset() : success(false), failure(false), ire(false) {}
3341
bool success;
3342
bool failure;
3343
bool ire;
3344
} _Cassandra_describe_token_map_result__isset;
3345
3346
class Cassandra_describe_token_map_result {
3347
public:
3348
3349
Cassandra_describe_token_map_result() {
3350
}
3351
3352
virtual ~Cassandra_describe_token_map_result() throw() {}
3353
3354
typedef apache::thrift::TApplicationException failure_t;
3355
typedef const std::map<std::string, std::string> & success_constref_nonvoid_t;
3356
typedef const std::map<std::string, std::string> & success_constref_t;
3357
typedef std::map<std::string, std::string> success_nonvoid_t;
3358
typedef std::map<std::string, std::string> success_t;
3359
std::map<std::string, std::string> success;
3360
apache::thrift::TApplicationException failure;
3361
InvalidRequestException ire;
3362
3363
_Cassandra_describe_token_map_result__isset __isset;
3364
3365
void __set_success(const std::map<std::string, std::string> & val) {
3366
success = val;
3367
}
3368
3369
void __set_failure(const apache::thrift::TApplicationException& val) {
3370
failure = val;
3371
}
3372
3373
void __set_ire(const InvalidRequestException& val) {
3374
ire = val;
3375
}
3376
3377
bool operator == (const Cassandra_describe_token_map_result & rhs) const
3378
{
3379
if (!(success == rhs.success))
3380
return false;
3381
if (!(ire == rhs.ire))
3382
return false;
3383
return true;
3384
}
3385
bool operator != (const Cassandra_describe_token_map_result &rhs) const {
3386
return !(*this == rhs);
3387
}
3388
3389
bool operator < (const Cassandra_describe_token_map_result & ) const;
3390
3391
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3392
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3393
3394
};
3395
3396
typedef struct _Cassandra_describe_token_map_presult__isset {
3397
_Cassandra_describe_token_map_presult__isset() : success(false), failure(false), ire(false) {}
3398
bool success;
3399
bool failure;
3400
bool ire;
3401
} _Cassandra_describe_token_map_presult__isset;
3402
3403
class Cassandra_describe_token_map_presult {
3404
public:
3405
3406
3407
virtual ~Cassandra_describe_token_map_presult() throw() {}
3408
3409
std::map<std::string, std::string> * success;
3410
apache::thrift::TApplicationException* failure;
3411
InvalidRequestException ire;
3412
3413
_Cassandra_describe_token_map_presult__isset __isset;
3414
3415
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3416
3417
};
3418
3419
3420
class Cassandra_describe_partitioner_args {
3421
public:
3422
3423
Cassandra_describe_partitioner_args() {
3424
}
3425
3426
virtual ~Cassandra_describe_partitioner_args() throw() {}
3427
3428
3429
bool operator == (const Cassandra_describe_partitioner_args & /* rhs */) const
3430
{
3431
return true;
3432
}
3433
bool operator != (const Cassandra_describe_partitioner_args &rhs) const {
3434
return !(*this == rhs);
3435
}
3436
3437
bool operator < (const Cassandra_describe_partitioner_args & ) const;
3438
3439
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3440
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3441
3442
};
3443
3444
3445
class Cassandra_describe_partitioner_pargs {
3446
public:
3447
3448
3449
virtual ~Cassandra_describe_partitioner_pargs() throw() {}
3450
3451
3452
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3453
3454
};
3455
3456
typedef struct _Cassandra_describe_partitioner_result__isset {
3457
_Cassandra_describe_partitioner_result__isset() : success(false), failure(false) {}
3458
bool success;
3459
bool failure;
3460
} _Cassandra_describe_partitioner_result__isset;
3461
3462
class Cassandra_describe_partitioner_result {
3463
public:
3464
3465
Cassandra_describe_partitioner_result() : success() {
3466
}
3467
3468
virtual ~Cassandra_describe_partitioner_result() throw() {}
3469
3470
typedef apache::thrift::TApplicationException failure_t;
3471
typedef const std::string& success_constref_nonvoid_t;
3472
typedef const std::string& success_constref_t;
3473
typedef std::string success_nonvoid_t;
3474
typedef std::string success_t;
3475
std::string success;
3476
apache::thrift::TApplicationException failure;
3477
3478
_Cassandra_describe_partitioner_result__isset __isset;
3479
3480
void __set_success(const std::string& val) {
3481
success = val;
3482
}
3483
3484
void __set_failure(const apache::thrift::TApplicationException& val) {
3485
failure = val;
3486
}
3487
3488
bool operator == (const Cassandra_describe_partitioner_result & rhs) const
3489
{
3490
if (!(success == rhs.success))
3491
return false;
3492
return true;
3493
}
3494
bool operator != (const Cassandra_describe_partitioner_result &rhs) const {
3495
return !(*this == rhs);
3496
}
3497
3498
bool operator < (const Cassandra_describe_partitioner_result & ) const;
3499
3500
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3501
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3502
3503
};
3504
3505
typedef struct _Cassandra_describe_partitioner_presult__isset {
3506
_Cassandra_describe_partitioner_presult__isset() : success(false), failure(false) {}
3507
bool success;
3508
bool failure;
3509
} _Cassandra_describe_partitioner_presult__isset;
3510
3511
class Cassandra_describe_partitioner_presult {
3512
public:
3513
3514
3515
virtual ~Cassandra_describe_partitioner_presult() throw() {}
3516
3517
std::string* success;
3518
apache::thrift::TApplicationException* failure;
3519
3520
_Cassandra_describe_partitioner_presult__isset __isset;
3521
3522
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3523
3524
};
3525
3526
3527
class Cassandra_describe_snitch_args {
3528
public:
3529
3530
Cassandra_describe_snitch_args() {
3531
}
3532
3533
virtual ~Cassandra_describe_snitch_args() throw() {}
3534
3535
3536
bool operator == (const Cassandra_describe_snitch_args & /* rhs */) const
3537
{
3538
return true;
3539
}
3540
bool operator != (const Cassandra_describe_snitch_args &rhs) const {
3541
return !(*this == rhs);
3542
}
3543
3544
bool operator < (const Cassandra_describe_snitch_args & ) const;
3545
3546
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3547
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3548
3549
};
3550
3551
3552
class Cassandra_describe_snitch_pargs {
3553
public:
3554
3555
3556
virtual ~Cassandra_describe_snitch_pargs() throw() {}
3557
3558
3559
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3560
3561
};
3562
3563
typedef struct _Cassandra_describe_snitch_result__isset {
3564
_Cassandra_describe_snitch_result__isset() : success(false), failure(false) {}
3565
bool success;
3566
bool failure;
3567
} _Cassandra_describe_snitch_result__isset;
3568
3569
class Cassandra_describe_snitch_result {
3570
public:
3571
3572
Cassandra_describe_snitch_result() : success() {
3573
}
3574
3575
virtual ~Cassandra_describe_snitch_result() throw() {}
3576
3577
typedef apache::thrift::TApplicationException failure_t;
3578
typedef const std::string& success_constref_nonvoid_t;
3579
typedef const std::string& success_constref_t;
3580
typedef std::string success_nonvoid_t;
3581
typedef std::string success_t;
3582
std::string success;
3583
apache::thrift::TApplicationException failure;
3584
3585
_Cassandra_describe_snitch_result__isset __isset;
3586
3587
void __set_success(const std::string& val) {
3588
success = val;
3589
}
3590
3591
void __set_failure(const apache::thrift::TApplicationException& val) {
3592
failure = val;
3593
}
3594
3595
bool operator == (const Cassandra_describe_snitch_result & rhs) const
3596
{
3597
if (!(success == rhs.success))
3598
return false;
3599
return true;
3600
}
3601
bool operator != (const Cassandra_describe_snitch_result &rhs) const {
3602
return !(*this == rhs);
3603
}
3604
3605
bool operator < (const Cassandra_describe_snitch_result & ) const;
3606
3607
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3608
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3609
3610
};
3611
3612
typedef struct _Cassandra_describe_snitch_presult__isset {
3613
_Cassandra_describe_snitch_presult__isset() : success(false), failure(false) {}
3614
bool success;
3615
bool failure;
3616
} _Cassandra_describe_snitch_presult__isset;
3617
3618
class Cassandra_describe_snitch_presult {
3619
public:
3620
3621
3622
virtual ~Cassandra_describe_snitch_presult() throw() {}
3623
3624
std::string* success;
3625
apache::thrift::TApplicationException* failure;
3626
3627
_Cassandra_describe_snitch_presult__isset __isset;
3628
3629
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3630
3631
};
3632
3633
3634
class Cassandra_describe_keyspace_args {
3635
public:
3636
3637
Cassandra_describe_keyspace_args() : keyspace() {
3638
}
3639
3640
virtual ~Cassandra_describe_keyspace_args() throw() {}
3641
3642
std::string keyspace;
3643
3644
void __set_keyspace(const std::string& val) {
3645
keyspace = val;
3646
}
3647
3648
bool operator == (const Cassandra_describe_keyspace_args & rhs) const
3649
{
3650
if (!(keyspace == rhs.keyspace))
3651
return false;
3652
return true;
3653
}
3654
bool operator != (const Cassandra_describe_keyspace_args &rhs) const {
3655
return !(*this == rhs);
3656
}
3657
3658
bool operator < (const Cassandra_describe_keyspace_args & ) const;
3659
3660
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3661
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3662
3663
};
3664
3665
3666
class Cassandra_describe_keyspace_pargs {
3667
public:
3668
3669
3670
virtual ~Cassandra_describe_keyspace_pargs() throw() {}
3671
3672
const std::string* keyspace;
3673
3674
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3675
3676
};
3677
3678
typedef struct _Cassandra_describe_keyspace_result__isset {
3679
_Cassandra_describe_keyspace_result__isset() : success(false), failure(false), nfe(false), ire(false) {}
3680
bool success;
3681
bool failure;
3682
bool nfe;
3683
bool ire;
3684
} _Cassandra_describe_keyspace_result__isset;
3685
3686
class Cassandra_describe_keyspace_result {
3687
public:
3688
3689
Cassandra_describe_keyspace_result() {
3690
}
3691
3692
virtual ~Cassandra_describe_keyspace_result() throw() {}
3693
3694
typedef apache::thrift::TApplicationException failure_t;
3695
typedef const KsDef& success_constref_nonvoid_t;
3696
typedef const KsDef& success_constref_t;
3697
typedef KsDef success_nonvoid_t;
3698
typedef KsDef success_t;
3699
KsDef success;
3700
apache::thrift::TApplicationException failure;
3701
NotFoundException nfe;
3702
InvalidRequestException ire;
3703
3704
_Cassandra_describe_keyspace_result__isset __isset;
3705
3706
void __set_success(const KsDef& val) {
3707
success = val;
3708
}
3709
3710
void __set_failure(const apache::thrift::TApplicationException& val) {
3711
failure = val;
3712
}
3713
3714
void __set_nfe(const NotFoundException& val) {
3715
nfe = val;
3716
}
3717
3718
void __set_ire(const InvalidRequestException& val) {
3719
ire = val;
3720
}
3721
3722
bool operator == (const Cassandra_describe_keyspace_result & rhs) const
3723
{
3724
if (!(success == rhs.success))
3725
return false;
3726
if (!(nfe == rhs.nfe))
3727
return false;
3728
if (!(ire == rhs.ire))
3729
return false;
3730
return true;
3731
}
3732
bool operator != (const Cassandra_describe_keyspace_result &rhs) const {
3733
return !(*this == rhs);
3734
}
3735
3736
bool operator < (const Cassandra_describe_keyspace_result & ) const;
3737
3738
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3739
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3740
3741
};
3742
3743
typedef struct _Cassandra_describe_keyspace_presult__isset {
3744
_Cassandra_describe_keyspace_presult__isset() : success(false), failure(false), nfe(false), ire(false) {}
3745
bool success;
3746
bool failure;
3747
bool nfe;
3748
bool ire;
3749
} _Cassandra_describe_keyspace_presult__isset;
3750
3751
class Cassandra_describe_keyspace_presult {
3752
public:
3753
3754
3755
virtual ~Cassandra_describe_keyspace_presult() throw() {}
3756
3757
KsDef* success;
3758
apache::thrift::TApplicationException* failure;
3759
NotFoundException nfe;
3760
InvalidRequestException ire;
3761
3762
_Cassandra_describe_keyspace_presult__isset __isset;
3763
3764
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3765
3766
};
3767
3768
3769
class Cassandra_describe_splits_args {
3770
public:
3771
3772
Cassandra_describe_splits_args() : cfName(), start_token(), end_token(), keys_per_split(0) {
3773
}
3774
3775
virtual ~Cassandra_describe_splits_args() throw() {}
3776
3777
std::string cfName;
3778
std::string start_token;
3779
std::string end_token;
3780
int32_t keys_per_split;
3781
3782
void __set_cfName(const std::string& val) {
3783
cfName = val;
3784
}
3785
3786
void __set_start_token(const std::string& val) {
3787
start_token = val;
3788
}
3789
3790
void __set_end_token(const std::string& val) {
3791
end_token = val;
3792
}
3793
3794
void __set_keys_per_split(const int32_t val) {
3795
keys_per_split = val;
3796
}
3797
3798
bool operator == (const Cassandra_describe_splits_args & rhs) const
3799
{
3800
if (!(cfName == rhs.cfName))
3801
return false;
3802
if (!(start_token == rhs.start_token))
3803
return false;
3804
if (!(end_token == rhs.end_token))
3805
return false;
3806
if (!(keys_per_split == rhs.keys_per_split))
3807
return false;
3808
return true;
3809
}
3810
bool operator != (const Cassandra_describe_splits_args &rhs) const {
3811
return !(*this == rhs);
3812
}
3813
3814
bool operator < (const Cassandra_describe_splits_args & ) const;
3815
3816
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3817
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3818
3819
};
3820
3821
3822
class Cassandra_describe_splits_pargs {
3823
public:
3824
3825
3826
virtual ~Cassandra_describe_splits_pargs() throw() {}
3827
3828
const std::string* cfName;
3829
const std::string* start_token;
3830
const std::string* end_token;
3831
const int32_t* keys_per_split;
3832
3833
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3834
3835
};
3836
3837
typedef struct _Cassandra_describe_splits_result__isset {
3838
_Cassandra_describe_splits_result__isset() : success(false), failure(false), ire(false) {}
3839
bool success;
3840
bool failure;
3841
bool ire;
3842
} _Cassandra_describe_splits_result__isset;
3843
3844
class Cassandra_describe_splits_result {
3845
public:
3846
3847
Cassandra_describe_splits_result() {
3848
}
3849
3850
virtual ~Cassandra_describe_splits_result() throw() {}
3851
3852
typedef apache::thrift::TApplicationException failure_t;
3853
typedef const std::vector<std::string> & success_constref_nonvoid_t;
3854
typedef const std::vector<std::string> & success_constref_t;
3855
typedef std::vector<std::string> success_nonvoid_t;
3856
typedef std::vector<std::string> success_t;
3857
std::vector<std::string> success;
3858
apache::thrift::TApplicationException failure;
3859
InvalidRequestException ire;
3860
3861
_Cassandra_describe_splits_result__isset __isset;
3862
3863
void __set_success(const std::vector<std::string> & val) {
3864
success = val;
3865
}
3866
3867
void __set_failure(const apache::thrift::TApplicationException& val) {
3868
failure = val;
3869
}
3870
3871
void __set_ire(const InvalidRequestException& val) {
3872
ire = val;
3873
}
3874
3875
bool operator == (const Cassandra_describe_splits_result & rhs) const
3876
{
3877
if (!(success == rhs.success))
3878
return false;
3879
if (!(ire == rhs.ire))
3880
return false;
3881
return true;
3882
}
3883
bool operator != (const Cassandra_describe_splits_result &rhs) const {
3884
return !(*this == rhs);
3885
}
3886
3887
bool operator < (const Cassandra_describe_splits_result & ) const;
3888
3889
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3890
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3891
3892
};
3893
3894
typedef struct _Cassandra_describe_splits_presult__isset {
3895
_Cassandra_describe_splits_presult__isset() : success(false), failure(false), ire(false) {}
3896
bool success;
3897
bool failure;
3898
bool ire;
3899
} _Cassandra_describe_splits_presult__isset;
3900
3901
class Cassandra_describe_splits_presult {
3902
public:
3903
3904
3905
virtual ~Cassandra_describe_splits_presult() throw() {}
3906
3907
std::vector<std::string> * success;
3908
apache::thrift::TApplicationException* failure;
3909
InvalidRequestException ire;
3910
3911
_Cassandra_describe_splits_presult__isset __isset;
3912
3913
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3914
3915
};
3916
3917
3918
class Cassandra_system_add_column_family_args {
3919
public:
3920
3921
Cassandra_system_add_column_family_args() {
3922
}
3923
3924
virtual ~Cassandra_system_add_column_family_args() throw() {}
3925
3926
CfDef cf_def;
3927
3928
void __set_cf_def(const CfDef& val) {
3929
cf_def = val;
3930
}
3931
3932
bool operator == (const Cassandra_system_add_column_family_args & rhs) const
3933
{
3934
if (!(cf_def == rhs.cf_def))
3935
return false;
3936
return true;
3937
}
3938
bool operator != (const Cassandra_system_add_column_family_args &rhs) const {
3939
return !(*this == rhs);
3940
}
3941
3942
bool operator < (const Cassandra_system_add_column_family_args & ) const;
3943
3944
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3945
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3946
3947
};
3948
3949
3950
class Cassandra_system_add_column_family_pargs {
3951
public:
3952
3953
3954
virtual ~Cassandra_system_add_column_family_pargs() throw() {}
3955
3956
const CfDef* cf_def;
3957
3958
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3959
3960
};
3961
3962
typedef struct _Cassandra_system_add_column_family_result__isset {
3963
_Cassandra_system_add_column_family_result__isset() : success(false), failure(false), ire(false), sde(false) {}
3964
bool success;
3965
bool failure;
3966
bool ire;
3967
bool sde;
3968
} _Cassandra_system_add_column_family_result__isset;
3969
3970
class Cassandra_system_add_column_family_result {
3971
public:
3972
3973
Cassandra_system_add_column_family_result() : success() {
3974
}
3975
3976
virtual ~Cassandra_system_add_column_family_result() throw() {}
3977
3978
typedef apache::thrift::TApplicationException failure_t;
3979
typedef const std::string& success_constref_nonvoid_t;
3980
typedef const std::string& success_constref_t;
3981
typedef std::string success_nonvoid_t;
3982
typedef std::string success_t;
3983
std::string success;
3984
apache::thrift::TApplicationException failure;
3985
InvalidRequestException ire;
3986
SchemaDisagreementException sde;
3987
3988
_Cassandra_system_add_column_family_result__isset __isset;
3989
3990
void __set_success(const std::string& val) {
3991
success = val;
3992
}
3993
3994
void __set_failure(const apache::thrift::TApplicationException& val) {
3995
failure = val;
3996
}
3997
3998
void __set_ire(const InvalidRequestException& val) {
3999
ire = val;
4000
}
4001
4002
void __set_sde(const SchemaDisagreementException& val) {
4003
sde = val;
4004
}
4005
4006
bool operator == (const Cassandra_system_add_column_family_result & rhs) const
4007
{
4008
if (!(success == rhs.success))
4009
return false;
4010
if (!(ire == rhs.ire))
4011
return false;
4012
if (!(sde == rhs.sde))
4013
return false;
4014
return true;
4015
}
4016
bool operator != (const Cassandra_system_add_column_family_result &rhs) const {
4017
return !(*this == rhs);
4018
}
4019
4020
bool operator < (const Cassandra_system_add_column_family_result & ) const;
4021
4022
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
4023
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
4024
4025
};
4026
4027
typedef struct _Cassandra_system_add_column_family_presult__isset {
4028
_Cassandra_system_add_column_family_presult__isset() : success(false), failure(false), ire(false), sde(false) {}
4029
bool success;
4030
bool failure;
4031
bool ire;
4032
bool sde;
4033
} _Cassandra_system_add_column_family_presult__isset;
4034
4035
class Cassandra_system_add_column_family_presult {
4036
public:
4037
4038
4039
virtual ~Cassandra_system_add_column_family_presult() throw() {}
4040
4041
std::string* success;
4042
apache::thrift::TApplicationException* failure;
4043
InvalidRequestException ire;
4044
SchemaDisagreementException sde;
4045
4046
_Cassandra_system_add_column_family_presult__isset __isset;
4047
4048
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
4049
4050
};
4051
4052
4053
class Cassandra_system_drop_column_family_args {
4054
public:
4055
4056
Cassandra_system_drop_column_family_args() : column_family() {
4057
}
4058
4059
virtual ~Cassandra_system_drop_column_family_args() throw() {}
4060
4061
std::string column_family;
4062
4063
void __set_column_family(const std::string& val) {
4064
column_family = val;
4065
}
4066
4067
bool operator == (const Cassandra_system_drop_column_family_args & rhs) const
4068
{
4069
if (!(column_family == rhs.column_family))
4070
return false;
4071
return true;
4072
}
4073
bool operator != (const Cassandra_system_drop_column_family_args &rhs) const {
4074
return !(*this == rhs);
4075
}
4076
4077
bool operator < (const Cassandra_system_drop_column_family_args & ) const;
4078
4079
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
4080
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
4081
4082
};
4083
4084
4085
class Cassandra_system_drop_column_family_pargs {
4086
public:
4087
4088
4089
virtual ~Cassandra_system_drop_column_family_pargs() throw() {}
4090
4091
const std::string* column_family;
4092
4093
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
4094
4095
};
4096
4097
typedef struct _Cassandra_system_drop_column_family_result__isset {
4098
_Cassandra_system_drop_column_family_result__isset() : success(false), failure(false), ire(false), sde(false) {}
4099
bool success;
4100
bool failure;
4101
bool ire;
4102
bool sde;
4103
} _Cassandra_system_drop_column_family_result__isset;
4104
4105
class Cassandra_system_drop_column_family_result {
4106
public:
4107
4108
Cassandra_system_drop_column_family_result() : success() {
4109
}
4110
4111
virtual ~Cassandra_system_drop_column_family_result() throw() {}
4112
4113
typedef apache::thrift::TApplicationException failure_t;
4114
typedef const std::string& success_constref_nonvoid_t;
4115
typedef const std::string& success_constref_t;
4116
typedef std::string success_nonvoid_t;
4117
typedef std::string success_t;
4118
std::string success;
4119
apache::thrift::TApplicationException failure;
4120
InvalidRequestException ire;
4121
SchemaDisagreementException sde;
4122
4123
_Cassandra_system_drop_column_family_result__isset __isset;
4124
4125
void __set_success(const std::string& val) {
4126
success = val;
4127
}
4128
4129
void __set_failure(const apache::thrift::TApplicationException& val) {
4130
failure = val;
4131
}
4132
4133
void __set_ire(const InvalidRequestException& val) {
4134
ire = val;
4135
}
4136
4137
void __set_sde(const SchemaDisagreementException& val) {
4138
sde = val;
4139
}
4140
4141
bool operator == (const Cassandra_system_drop_column_family_result & rhs) const
4142
{
4143
if (!(success == rhs.success))
4144
return false;
4145
if (!(ire == rhs.ire))
4146
return false;
4147
if (!(sde == rhs.sde))
4148
return false;
4149
return true;
4150
}
4151
bool operator != (const Cassandra_system_drop_column_family_result &rhs) const {
4152
return !(*this == rhs);
4153
}
4154
4155
bool operator < (const Cassandra_system_drop_column_family_result & ) const;
4156
4157
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
4158
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
4159
4160
};
4161
4162
typedef struct _Cassandra_system_drop_column_family_presult__isset {
4163
_Cassandra_system_drop_column_family_presult__isset() : success(false), failure(false), ire(false), sde(false) {}
4164
bool success;
4165
bool failure;
4166
bool ire;
4167
bool sde;
4168
} _Cassandra_system_drop_column_family_presult__isset;
4169
4170
class Cassandra_system_drop_column_family_presult {
4171
public:
4172
4173
4174
virtual ~Cassandra_system_drop_column_family_presult() throw() {}
4175
4176
std::string* success;
4177
apache::thrift::TApplicationException* failure;
4178
InvalidRequestException ire;
4179
SchemaDisagreementException sde;
4180
4181
_Cassandra_system_drop_column_family_presult__isset __isset;
4182
4183
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
4184
4185
};
4186
4187
4188
class Cassandra_system_add_keyspace_args {
4189
public:
4190
4191
Cassandra_system_add_keyspace_args() {
4192
}
4193
4194
virtual ~Cassandra_system_add_keyspace_args() throw() {}
4195
4196
KsDef ks_def;
4197
4198
void __set_ks_def(const KsDef& val) {
4199
ks_def = val;
4200
}
4201
4202
bool operator == (const Cassandra_system_add_keyspace_args & rhs) const
4203
{
4204
if (!(ks_def == rhs.ks_def))
4205
return false;
4206
return true;
4207
}
4208
bool operator != (const Cassandra_system_add_keyspace_args &rhs) const {
4209
return !(*this == rhs);
4210
}
4211
4212
bool operator < (const Cassandra_system_add_keyspace_args & ) const;
4213
4214
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
4215
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
4216
4217
};
4218
4219
4220
class Cassandra_system_add_keyspace_pargs {
4221
public:
4222
4223
4224
virtual ~Cassandra_system_add_keyspace_pargs() throw() {}
4225
4226
const KsDef* ks_def;
4227
4228
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
4229
4230
};
4231
4232
typedef struct _Cassandra_system_add_keyspace_result__isset {
4233
_Cassandra_system_add_keyspace_result__isset() : success(false), failure(false), ire(false), sde(false) {}
4234
bool success;
4235
bool failure;
4236
bool ire;
4237
bool sde;
4238
} _Cassandra_system_add_keyspace_result__isset;
4239
4240
class Cassandra_system_add_keyspace_result {
4241
public:
4242
4243
Cassandra_system_add_keyspace_result() : success() {
4244
}
4245
4246
virtual ~Cassandra_system_add_keyspace_result() throw() {}
4247
4248
typedef apache::thrift::TApplicationException failure_t;
4249
typedef const std::string& success_constref_nonvoid_t;
4250
typedef const std::string& success_constref_t;
4251
typedef std::string success_nonvoid_t;
4252
typedef std::string success_t;
4253
std::string success;
4254
apache::thrift::TApplicationException failure;
4255
InvalidRequestException ire;
4256
SchemaDisagreementException sde;
4257
4258
_Cassandra_system_add_keyspace_result__isset __isset;
4259
4260
void __set_success(const std::string& val) {
4261
success = val;
4262
}
4263
4264
void __set_failure(const apache::thrift::TApplicationException& val) {
4265
failure = val;
4266
}
4267
4268
void __set_ire(const InvalidRequestException& val) {
4269
ire = val;
4270
}
4271
4272
void __set_sde(const SchemaDisagreementException& val) {
4273
sde = val;
4274
}
4275
4276
bool operator == (const Cassandra_system_add_keyspace_result & rhs) const
4277
{
4278
if (!(success == rhs.success))
4279
return false;
4280
if (!(ire == rhs.ire))
4281
return false;
4282
if (!(sde == rhs.sde))
4283
return false;
4284
return true;
4285
}
4286
bool operator != (const Cassandra_system_add_keyspace_result &rhs) const {
4287
return !(*this == rhs);
4288
}
4289
4290
bool operator < (const Cassandra_system_add_keyspace_result & ) const;
4291
4292
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
4293
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
4294
4295
};
4296
4297
typedef struct _Cassandra_system_add_keyspace_presult__isset {
4298
_Cassandra_system_add_keyspace_presult__isset() : success(false), failure(false), ire(false), sde(false) {}
4299
bool success;
4300
bool failure;
4301
bool ire;
4302
bool sde;
4303
} _Cassandra_system_add_keyspace_presult__isset;
4304
4305
class Cassandra_system_add_keyspace_presult {
4306
public:
4307
4308
4309
virtual ~Cassandra_system_add_keyspace_presult() throw() {}
4310
4311
std::string* success;
4312
apache::thrift::TApplicationException* failure;
4313
InvalidRequestException ire;
4314
SchemaDisagreementException sde;
4315
4316
_Cassandra_system_add_keyspace_presult__isset __isset;
4317
4318
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
4319
4320
};
4321
4322
4323
class Cassandra_system_drop_keyspace_args {
4324
public:
4325
4326
Cassandra_system_drop_keyspace_args() : keyspace() {
4327
}
4328
4329
virtual ~Cassandra_system_drop_keyspace_args() throw() {}
4330
4331
std::string keyspace;
4332
4333
void __set_keyspace(const std::string& val) {
4334
keyspace = val;
4335
}
4336
4337
bool operator == (const Cassandra_system_drop_keyspace_args & rhs) const
4338
{
4339
if (!(keyspace == rhs.keyspace))
4340
return false;
4341
return true;
4342
}
4343
bool operator != (const Cassandra_system_drop_keyspace_args &rhs) const {
4344
return !(*this == rhs);
4345
}
4346
4347
bool operator < (const Cassandra_system_drop_keyspace_args & ) const;
4348
4349
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
4350
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
4351
4352
};
4353
4354
4355
class Cassandra_system_drop_keyspace_pargs {
4356
public:
4357
4358
4359
virtual ~Cassandra_system_drop_keyspace_pargs() throw() {}
4360
4361
const std::string* keyspace;
4362
4363
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
4364
4365
};
4366
4367
typedef struct _Cassandra_system_drop_keyspace_result__isset {
4368
_Cassandra_system_drop_keyspace_result__isset() : success(false), failure(false), ire(false), sde(false) {}
4369
bool success;
4370
bool failure;
4371
bool ire;
4372
bool sde;
4373
} _Cassandra_system_drop_keyspace_result__isset;
4374
4375
class Cassandra_system_drop_keyspace_result {
4376
public:
4377
4378
Cassandra_system_drop_keyspace_result() : success() {
4379
}
4380
4381
virtual ~Cassandra_system_drop_keyspace_result() throw() {}
4382
4383
typedef apache::thrift::TApplicationException failure_t;
4384
typedef const std::string& success_constref_nonvoid_t;
4385
typedef const std::string& success_constref_t;
4386
typedef std::string success_nonvoid_t;
4387
typedef std::string success_t;
4388
std::string success;
4389
apache::thrift::TApplicationException failure;
4390
InvalidRequestException ire;
4391
SchemaDisagreementException sde;
4392
4393
_Cassandra_system_drop_keyspace_result__isset __isset;
4394
4395
void __set_success(const std::string& val) {