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