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