← Back to branch summary

~maria-captains/maria/5.5-cassandra-parallel

« back to all changes in this revision

Viewing changes to storage/cassandra/gen-cpp-async/cassandra_types.h

  • Committer: Sergey Petrunya
  • Date: 2012-09-20 14:32:37 UTC
  • Revision ID: psergey@askmonty.org-20120920143237-og4d9qh8uiojasmi
Casandra SE:
- Introduce asynchronous operations
- parallel INSERT operation.

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/cassandra/gen-cpp-async/cassandra_types.h
 
1
/**
 
2
 * Autogenerated by Thrift Compiler (0.9.0-dev)
 
3
 *
 
4
 * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 
5
 *  @generated
 
6
 */
 
7
#ifndef cassandra_TYPES_H
 
8
#define cassandra_TYPES_H
 
9
 
 
10
#include <boost/bind.hpp>
 
11
#include <boost/function.hpp>
 
12
#include <async/TAsync.h>
 
13
#include <async/TFuture.h>
 
14
#include <concurrency/Mutex.h>
 
15
 
 
16
#include <thrift/Thrift.h>
 
17
#include <thrift/TApplicationException.h>
 
18
#include <thrift/protocol/TProtocol.h>
 
19
#include <thrift/transport/TTransport.h>
 
20
 
 
21
 
 
22
 
 
23
namespace org { namespace apache { namespace cassandra {
 
24
 
 
25
struct ConsistencyLevel {
 
26
  enum type {
 
27
    ONE = 1,
 
28
    QUORUM = 2,
 
29
    LOCAL_QUORUM = 3,
 
30
    EACH_QUORUM = 4,
 
31
    ALL = 5,
 
32
    ANY = 6,
 
33
    TWO = 7,
 
34
    THREE = 8
 
35
  };
 
36
};
 
37
 
 
38
extern const std::map<int, const char*> _ConsistencyLevel_VALUES_TO_NAMES;
 
39
 
 
40
struct IndexOperator {
 
41
  enum type {
 
42
    EQ = 0,
 
43
    GTE = 1,
 
44
    GT = 2,
 
45
    LTE = 3,
 
46
    LT = 4
 
47
  };
 
48
};
 
49
 
 
50
extern const std::map<int, const char*> _IndexOperator_VALUES_TO_NAMES;
 
51
 
 
52
struct IndexType {
 
53
  enum type {
 
54
    KEYS = 0,
 
55
    CUSTOM = 1
 
56
  };
 
57
};
 
58
 
 
59
extern const std::map<int, const char*> _IndexType_VALUES_TO_NAMES;
 
60
 
 
61
struct Compression {
 
62
  enum type {
 
63
    GZIP = 1,
 
64
    NONE = 2
 
65
  };
 
66
};
 
67
 
 
68
extern const std::map<int, const char*> _Compression_VALUES_TO_NAMES;
 
69
 
 
70
struct CqlResultType {
 
71
  enum type {
 
72
    ROWS = 1,
 
73
    VOID = 2,
 
74
    INT = 3
 
75
  };
 
76
};
 
77
 
 
78
extern const std::map<int, const char*> _CqlResultType_VALUES_TO_NAMES;
 
79
 
 
80
typedef struct _Column__isset {
 
81
  _Column__isset() : value(false), timestamp(false), ttl(false) {}
 
82
  bool value;
 
83
  bool timestamp;
 
84
  bool ttl;
 
85
} _Column__isset;
 
86
 
 
87
class Column {
 
88
 public:
 
89
 
 
90
  static const char* ascii_fingerprint; // = "3EE0E1C5C844001B62F08125068292CC";
 
91
  static const uint8_t binary_fingerprint[16]; // = {0x3E,0xE0,0xE1,0xC5,0xC8,0x44,0x00,0x1B,0x62,0xF0,0x81,0x25,0x06,0x82,0x92,0xCC};
 
92
 
 
93
  Column() : name(), value(), timestamp(0), ttl(0) {
 
94
  }
 
95
 
 
96
  virtual ~Column() throw() {}
 
97
 
 
98
  std::string name;
 
99
  std::string value;
 
100
  int64_t timestamp;
 
101
  int32_t ttl;
 
102
 
 
103
  _Column__isset __isset;
 
104
 
 
105
  void __set_name(const std::string& val) {
 
106
    name = val;
 
107
  }
 
108
 
 
109
  void __set_value(const std::string& val) {
 
110
    value = val;
 
111
    __isset.value = true;
 
112
  }
 
113
 
 
114
  void __set_timestamp(const int64_t val) {
 
115
    timestamp = val;
 
116
    __isset.timestamp = true;
 
117
  }
 
118
 
 
119
  void __set_ttl(const int32_t val) {
 
120
    ttl = val;
 
121
    __isset.ttl = true;
 
122
  }
 
123
 
 
124
  bool operator == (const Column & rhs) const
 
125
  {
 
126
    if (!(name == rhs.name))
 
127
      return false;
 
128
    if (__isset.value != rhs.__isset.value)
 
129
      return false;
 
130
    else if (__isset.value && !(value == rhs.value))
 
131
      return false;
 
132
    if (__isset.timestamp != rhs.__isset.timestamp)
 
133
      return false;
 
134
    else if (__isset.timestamp && !(timestamp == rhs.timestamp))
 
135
      return false;
 
136
    if (__isset.ttl != rhs.__isset.ttl)
 
137
      return false;
 
138
    else if (__isset.ttl && !(ttl == rhs.ttl))
 
139
      return false;
 
140
    return true;
 
141
  }
 
142
  bool operator != (const Column &rhs) const {
 
143
    return !(*this == rhs);
 
144
  }
 
145
 
 
146
  bool operator < (const Column & ) const;
 
147
 
 
148
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
149
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
150
 
 
151
};
 
152
 
 
153
void swap(Column &a, Column &b);
 
154
 
 
155
 
 
156
class SuperColumn {
 
157
 public:
 
158
 
 
159
  static const char* ascii_fingerprint; // = "470EFC558004E98D92D604898305C04E";
 
160
  static const uint8_t binary_fingerprint[16]; // = {0x47,0x0E,0xFC,0x55,0x80,0x04,0xE9,0x8D,0x92,0xD6,0x04,0x89,0x83,0x05,0xC0,0x4E};
 
161
 
 
162
  SuperColumn() : name() {
 
163
  }
 
164
 
 
165
  virtual ~SuperColumn() throw() {}
 
166
 
 
167
  std::string name;
 
168
  std::vector<Column>  columns;
 
169
 
 
170
  void __set_name(const std::string& val) {
 
171
    name = val;
 
172
  }
 
173
 
 
174
  void __set_columns(const std::vector<Column> & val) {
 
175
    columns = val;
 
176
  }
 
177
 
 
178
  bool operator == (const SuperColumn & rhs) const
 
179
  {
 
180
    if (!(name == rhs.name))
 
181
      return false;
 
182
    if (!(columns == rhs.columns))
 
183
      return false;
 
184
    return true;
 
185
  }
 
186
  bool operator != (const SuperColumn &rhs) const {
 
187
    return !(*this == rhs);
 
188
  }
 
189
 
 
190
  bool operator < (const SuperColumn & ) const;
 
191
 
 
192
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
193
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
194
 
 
195
};
 
196
 
 
197
void swap(SuperColumn &a, SuperColumn &b);
 
198
 
 
199
 
 
200
class CounterColumn {
 
201
 public:
 
202
 
 
203
  static const char* ascii_fingerprint; // = "1CCCF6FC31CFD1D61BBBB1BAF3590620";
 
204
  static const uint8_t binary_fingerprint[16]; // = {0x1C,0xCC,0xF6,0xFC,0x31,0xCF,0xD1,0xD6,0x1B,0xBB,0xB1,0xBA,0xF3,0x59,0x06,0x20};
 
205
 
 
206
  CounterColumn() : name(), value(0) {
 
207
  }
 
208
 
 
209
  virtual ~CounterColumn() throw() {}
 
210
 
 
211
  std::string name;
 
212
  int64_t value;
 
213
 
 
214
  void __set_name(const std::string& val) {
 
215
    name = val;
 
216
  }
 
217
 
 
218
  void __set_value(const int64_t val) {
 
219
    value = val;
 
220
  }
 
221
 
 
222
  bool operator == (const CounterColumn & rhs) const
 
223
  {
 
224
    if (!(name == rhs.name))
 
225
      return false;
 
226
    if (!(value == rhs.value))
 
227
      return false;
 
228
    return true;
 
229
  }
 
230
  bool operator != (const CounterColumn &rhs) const {
 
231
    return !(*this == rhs);
 
232
  }
 
233
 
 
234
  bool operator < (const CounterColumn & ) const;
 
235
 
 
236
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
237
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
238
 
 
239
};
 
240
 
 
241
void swap(CounterColumn &a, CounterColumn &b);
 
242
 
 
243
 
 
244
class CounterSuperColumn {
 
245
 public:
 
246
 
 
247
  static const char* ascii_fingerprint; // = "CD4C8C4BF7753E46DE417CDE369343A4";
 
248
  static const uint8_t binary_fingerprint[16]; // = {0xCD,0x4C,0x8C,0x4B,0xF7,0x75,0x3E,0x46,0xDE,0x41,0x7C,0xDE,0x36,0x93,0x43,0xA4};
 
249
 
 
250
  CounterSuperColumn() : name() {
 
251
  }
 
252
 
 
253
  virtual ~CounterSuperColumn() throw() {}
 
254
 
 
255
  std::string name;
 
256
  std::vector<CounterColumn>  columns;
 
257
 
 
258
  void __set_name(const std::string& val) {
 
259
    name = val;
 
260
  }
 
261
 
 
262
  void __set_columns(const std::vector<CounterColumn> & val) {
 
263
    columns = val;
 
264
  }
 
265
 
 
266
  bool operator == (const CounterSuperColumn & rhs) const
 
267
  {
 
268
    if (!(name == rhs.name))
 
269
      return false;
 
270
    if (!(columns == rhs.columns))
 
271
      return false;
 
272
    return true;
 
273
  }
 
274
  bool operator != (const CounterSuperColumn &rhs) const {
 
275
    return !(*this == rhs);
 
276
  }
 
277
 
 
278
  bool operator < (const CounterSuperColumn & ) const;
 
279
 
 
280
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
281
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
282
 
 
283
};
 
284
 
 
285
void swap(CounterSuperColumn &a, CounterSuperColumn &b);
 
286
 
 
287
typedef struct _ColumnOrSuperColumn__isset {
 
288
  _ColumnOrSuperColumn__isset() : column(false), super_column(false), counter_column(false), counter_super_column(false) {}
 
289
  bool column;
 
290
  bool super_column;
 
291
  bool counter_column;
 
292
  bool counter_super_column;
 
293
} _ColumnOrSuperColumn__isset;
 
294
 
 
295
class ColumnOrSuperColumn {
 
296
 public:
 
297
 
 
298
  static const char* ascii_fingerprint; // = "2B34AC9E80F1DAA3A2A63B1AB1841E61";
 
299
  static const uint8_t binary_fingerprint[16]; // = {0x2B,0x34,0xAC,0x9E,0x80,0xF1,0xDA,0xA3,0xA2,0xA6,0x3B,0x1A,0xB1,0x84,0x1E,0x61};
 
300
 
 
301
  ColumnOrSuperColumn() {
 
302
  }
 
303
 
 
304
  virtual ~ColumnOrSuperColumn() throw() {}
 
305
 
 
306
  Column column;
 
307
  SuperColumn super_column;
 
308
  CounterColumn counter_column;
 
309
  CounterSuperColumn counter_super_column;
 
310
 
 
311
  _ColumnOrSuperColumn__isset __isset;
 
312
 
 
313
  void __set_column(const Column& val) {
 
314
    column = val;
 
315
    __isset.column = true;
 
316
  }
 
317
 
 
318
  void __set_super_column(const SuperColumn& val) {
 
319
    super_column = val;
 
320
    __isset.super_column = true;
 
321
  }
 
322
 
 
323
  void __set_counter_column(const CounterColumn& val) {
 
324
    counter_column = val;
 
325
    __isset.counter_column = true;
 
326
  }
 
327
 
 
328
  void __set_counter_super_column(const CounterSuperColumn& val) {
 
329
    counter_super_column = val;
 
330
    __isset.counter_super_column = true;
 
331
  }
 
332
 
 
333
  bool operator == (const ColumnOrSuperColumn & rhs) const
 
334
  {
 
335
    if (__isset.column != rhs.__isset.column)
 
336
      return false;
 
337
    else if (__isset.column && !(column == rhs.column))
 
338
      return false;
 
339
    if (__isset.super_column != rhs.__isset.super_column)
 
340
      return false;
 
341
    else if (__isset.super_column && !(super_column == rhs.super_column))
 
342
      return false;
 
343
    if (__isset.counter_column != rhs.__isset.counter_column)
 
344
      return false;
 
345
    else if (__isset.counter_column && !(counter_column == rhs.counter_column))
 
346
      return false;
 
347
    if (__isset.counter_super_column != rhs.__isset.counter_super_column)
 
348
      return false;
 
349
    else if (__isset.counter_super_column && !(counter_super_column == rhs.counter_super_column))
 
350
      return false;
 
351
    return true;
 
352
  }
 
353
  bool operator != (const ColumnOrSuperColumn &rhs) const {
 
354
    return !(*this == rhs);
 
355
  }
 
356
 
 
357
  bool operator < (const ColumnOrSuperColumn & ) const;
 
358
 
 
359
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
360
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
361
 
 
362
};
 
363
 
 
364
void swap(ColumnOrSuperColumn &a, ColumnOrSuperColumn &b);
 
365
 
 
366
 
 
367
class NotFoundException : public ::apache::thrift::TException {
 
368
 public:
 
369
 
 
370
  static const char* ascii_fingerprint; // = "99914B932BD37A50B983C5E7C90AE93B";
 
371
  static const uint8_t binary_fingerprint[16]; // = {0x99,0x91,0x4B,0x93,0x2B,0xD3,0x7A,0x50,0xB9,0x83,0xC5,0xE7,0xC9,0x0A,0xE9,0x3B};
 
372
 
 
373
  NotFoundException() {
 
374
  }
 
375
 
 
376
  virtual ~NotFoundException() throw() {}
 
377
 
 
378
 
 
379
  bool operator == (const NotFoundException & /* rhs */) const
 
380
  {
 
381
    return true;
 
382
  }
 
383
  bool operator != (const NotFoundException &rhs) const {
 
384
    return !(*this == rhs);
 
385
  }
 
386
 
 
387
  bool operator < (const NotFoundException & ) const;
 
388
 
 
389
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
390
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
391
 
 
392
};
 
393
 
 
394
void swap(NotFoundException &a, NotFoundException &b);
 
395
 
 
396
 
 
397
class InvalidRequestException : public ::apache::thrift::TException {
 
398
 public:
 
399
 
 
400
  static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1";
 
401
  static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
 
402
 
 
403
  InvalidRequestException() : why() {
 
404
  }
 
405
 
 
406
  virtual ~InvalidRequestException() throw() {}
 
407
 
 
408
  std::string why;
 
409
 
 
410
  void __set_why(const std::string& val) {
 
411
    why = val;
 
412
  }
 
413
 
 
414
  bool operator == (const InvalidRequestException & rhs) const
 
415
  {
 
416
    if (!(why == rhs.why))
 
417
      return false;
 
418
    return true;
 
419
  }
 
420
  bool operator != (const InvalidRequestException &rhs) const {
 
421
    return !(*this == rhs);
 
422
  }
 
423
 
 
424
  bool operator < (const InvalidRequestException & ) const;
 
425
 
 
426
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
427
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
428
 
 
429
};
 
430
 
 
431
void swap(InvalidRequestException &a, InvalidRequestException &b);
 
432
 
 
433
 
 
434
class UnavailableException : public ::apache::thrift::TException {
 
435
 public:
 
436
 
 
437
  static const char* ascii_fingerprint; // = "99914B932BD37A50B983C5E7C90AE93B";
 
438
  static const uint8_t binary_fingerprint[16]; // = {0x99,0x91,0x4B,0x93,0x2B,0xD3,0x7A,0x50,0xB9,0x83,0xC5,0xE7,0xC9,0x0A,0xE9,0x3B};
 
439
 
 
440
  UnavailableException() {
 
441
  }
 
442
 
 
443
  virtual ~UnavailableException() throw() {}
 
444
 
 
445
 
 
446
  bool operator == (const UnavailableException & /* rhs */) const
 
447
  {
 
448
    return true;
 
449
  }
 
450
  bool operator != (const UnavailableException &rhs) const {
 
451
    return !(*this == rhs);
 
452
  }
 
453
 
 
454
  bool operator < (const UnavailableException & ) const;
 
455
 
 
456
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
457
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
458
 
 
459
};
 
460
 
 
461
void swap(UnavailableException &a, UnavailableException &b);
 
462
 
 
463
 
 
464
class TimedOutException : public ::apache::thrift::TException {
 
465
 public:
 
466
 
 
467
  static const char* ascii_fingerprint; // = "99914B932BD37A50B983C5E7C90AE93B";
 
468
  static const uint8_t binary_fingerprint[16]; // = {0x99,0x91,0x4B,0x93,0x2B,0xD3,0x7A,0x50,0xB9,0x83,0xC5,0xE7,0xC9,0x0A,0xE9,0x3B};
 
469
 
 
470
  TimedOutException() {
 
471
  }
 
472
 
 
473
  virtual ~TimedOutException() throw() {}
 
474
 
 
475
 
 
476
  bool operator == (const TimedOutException & /* rhs */) const
 
477
  {
 
478
    return true;
 
479
  }
 
480
  bool operator != (const TimedOutException &rhs) const {
 
481
    return !(*this == rhs);
 
482
  }
 
483
 
 
484
  bool operator < (const TimedOutException & ) const;
 
485
 
 
486
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
487
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
488
 
 
489
};
 
490
 
 
491
void swap(TimedOutException &a, TimedOutException &b);
 
492
 
 
493
 
 
494
class AuthenticationException : public ::apache::thrift::TException {
 
495
 public:
 
496
 
 
497
  static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1";
 
498
  static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
 
499
 
 
500
  AuthenticationException() : why() {
 
501
  }
 
502
 
 
503
  virtual ~AuthenticationException() throw() {}
 
504
 
 
505
  std::string why;
 
506
 
 
507
  void __set_why(const std::string& val) {
 
508
    why = val;
 
509
  }
 
510
 
 
511
  bool operator == (const AuthenticationException & rhs) const
 
512
  {
 
513
    if (!(why == rhs.why))
 
514
      return false;
 
515
    return true;
 
516
  }
 
517
  bool operator != (const AuthenticationException &rhs) const {
 
518
    return !(*this == rhs);
 
519
  }
 
520
 
 
521
  bool operator < (const AuthenticationException & ) const;
 
522
 
 
523
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
524
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
525
 
 
526
};
 
527
 
 
528
void swap(AuthenticationException &a, AuthenticationException &b);
 
529
 
 
530
 
 
531
class AuthorizationException : public ::apache::thrift::TException {
 
532
 public:
 
533
 
 
534
  static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1";
 
535
  static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
 
536
 
 
537
  AuthorizationException() : why() {
 
538
  }
 
539
 
 
540
  virtual ~AuthorizationException() throw() {}
 
541
 
 
542
  std::string why;
 
543
 
 
544
  void __set_why(const std::string& val) {
 
545
    why = val;
 
546
  }
 
547
 
 
548
  bool operator == (const AuthorizationException & rhs) const
 
549
  {
 
550
    if (!(why == rhs.why))
 
551
      return false;
 
552
    return true;
 
553
  }
 
554
  bool operator != (const AuthorizationException &rhs) const {
 
555
    return !(*this == rhs);
 
556
  }
 
557
 
 
558
  bool operator < (const AuthorizationException & ) const;
 
559
 
 
560
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
561
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
562
 
 
563
};
 
564
 
 
565
void swap(AuthorizationException &a, AuthorizationException &b);
 
566
 
 
567
 
 
568
class SchemaDisagreementException : public ::apache::thrift::TException {
 
569
 public:
 
570
 
 
571
  static const char* ascii_fingerprint; // = "99914B932BD37A50B983C5E7C90AE93B";
 
572
  static const uint8_t binary_fingerprint[16]; // = {0x99,0x91,0x4B,0x93,0x2B,0xD3,0x7A,0x50,0xB9,0x83,0xC5,0xE7,0xC9,0x0A,0xE9,0x3B};
 
573
 
 
574
  SchemaDisagreementException() {
 
575
  }
 
576
 
 
577
  virtual ~SchemaDisagreementException() throw() {}
 
578
 
 
579
 
 
580
  bool operator == (const SchemaDisagreementException & /* rhs */) const
 
581
  {
 
582
    return true;
 
583
  }
 
584
  bool operator != (const SchemaDisagreementException &rhs) const {
 
585
    return !(*this == rhs);
 
586
  }
 
587
 
 
588
  bool operator < (const SchemaDisagreementException & ) const;
 
589
 
 
590
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
591
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
592
 
 
593
};
 
594
 
 
595
void swap(SchemaDisagreementException &a, SchemaDisagreementException &b);
 
596
 
 
597
typedef struct _ColumnParent__isset {
 
598
  _ColumnParent__isset() : super_column(false) {}
 
599
  bool super_column;
 
600
} _ColumnParent__isset;
 
601
 
 
602
class ColumnParent {
 
603
 public:
 
604
 
 
605
  static const char* ascii_fingerprint; // = "0A13AE61181713A4100DFFB3EC293822";
 
606
  static const uint8_t binary_fingerprint[16]; // = {0x0A,0x13,0xAE,0x61,0x18,0x17,0x13,0xA4,0x10,0x0D,0xFF,0xB3,0xEC,0x29,0x38,0x22};
 
607
 
 
608
  ColumnParent() : column_family(), super_column() {
 
609
  }
 
610
 
 
611
  virtual ~ColumnParent() throw() {}
 
612
 
 
613
  std::string column_family;
 
614
  std::string super_column;
 
615
 
 
616
  _ColumnParent__isset __isset;
 
617
 
 
618
  void __set_column_family(const std::string& val) {
 
619
    column_family = val;
 
620
  }
 
621
 
 
622
  void __set_super_column(const std::string& val) {
 
623
    super_column = val;
 
624
    __isset.super_column = true;
 
625
  }
 
626
 
 
627
  bool operator == (const ColumnParent & rhs) const
 
628
  {
 
629
    if (!(column_family == rhs.column_family))
 
630
      return false;
 
631
    if (__isset.super_column != rhs.__isset.super_column)
 
632
      return false;
 
633
    else if (__isset.super_column && !(super_column == rhs.super_column))
 
634
      return false;
 
635
    return true;
 
636
  }
 
637
  bool operator != (const ColumnParent &rhs) const {
 
638
    return !(*this == rhs);
 
639
  }
 
640
 
 
641
  bool operator < (const ColumnParent & ) const;
 
642
 
 
643
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
644
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
645
 
 
646
};
 
647
 
 
648
void swap(ColumnParent &a, ColumnParent &b);
 
649
 
 
650
typedef struct _ColumnPath__isset {
 
651
  _ColumnPath__isset() : super_column(false), column(false) {}
 
652
  bool super_column;
 
653
  bool column;
 
654
} _ColumnPath__isset;
 
655
 
 
656
class ColumnPath {
 
657
 public:
 
658
 
 
659
  static const char* ascii_fingerprint; // = "606212895BCF63C757913CF35AEB3462";
 
660
  static const uint8_t binary_fingerprint[16]; // = {0x60,0x62,0x12,0x89,0x5B,0xCF,0x63,0xC7,0x57,0x91,0x3C,0xF3,0x5A,0xEB,0x34,0x62};
 
661
 
 
662
  ColumnPath() : column_family(), super_column(), column() {
 
663
  }
 
664
 
 
665
  virtual ~ColumnPath() throw() {}
 
666
 
 
667
  std::string column_family;
 
668
  std::string super_column;
 
669
  std::string column;
 
670
 
 
671
  _ColumnPath__isset __isset;
 
672
 
 
673
  void __set_column_family(const std::string& val) {
 
674
    column_family = val;
 
675
  }
 
676
 
 
677
  void __set_super_column(const std::string& val) {
 
678
    super_column = val;
 
679
    __isset.super_column = true;
 
680
  }
 
681
 
 
682
  void __set_column(const std::string& val) {
 
683
    column = val;
 
684
    __isset.column = true;
 
685
  }
 
686
 
 
687
  bool operator == (const ColumnPath & rhs) const
 
688
  {
 
689
    if (!(column_family == rhs.column_family))
 
690
      return false;
 
691
    if (__isset.super_column != rhs.__isset.super_column)
 
692
      return false;
 
693
    else if (__isset.super_column && !(super_column == rhs.super_column))
 
694
      return false;
 
695
    if (__isset.column != rhs.__isset.column)
 
696
      return false;
 
697
    else if (__isset.column && !(column == rhs.column))
 
698
      return false;
 
699
    return true;
 
700
  }
 
701
  bool operator != (const ColumnPath &rhs) const {
 
702
    return !(*this == rhs);
 
703
  }
 
704
 
 
705
  bool operator < (const ColumnPath & ) const;
 
706
 
 
707
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
708
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
709
 
 
710
};
 
711
 
 
712
void swap(ColumnPath &a, ColumnPath &b);
 
713
 
 
714
 
 
715
class SliceRange {
 
716
 public:
 
717
 
 
718
  static const char* ascii_fingerprint; // = "184D24C9A0B8D4415E234DB649CAE740";
 
719
  static const uint8_t binary_fingerprint[16]; // = {0x18,0x4D,0x24,0xC9,0xA0,0xB8,0xD4,0x41,0x5E,0x23,0x4D,0xB6,0x49,0xCA,0xE7,0x40};
 
720
 
 
721
  SliceRange() : start(), finish(), reversed(false), count(100) {
 
722
  }
 
723
 
 
724
  virtual ~SliceRange() throw() {}
 
725
 
 
726
  std::string start;
 
727
  std::string finish;
 
728
  bool reversed;
 
729
  int32_t count;
 
730
 
 
731
  void __set_start(const std::string& val) {
 
732
    start = val;
 
733
  }
 
734
 
 
735
  void __set_finish(const std::string& val) {
 
736
    finish = val;
 
737
  }
 
738
 
 
739
  void __set_reversed(const bool val) {
 
740
    reversed = val;
 
741
  }
 
742
 
 
743
  void __set_count(const int32_t val) {
 
744
    count = val;
 
745
  }
 
746
 
 
747
  bool operator == (const SliceRange & rhs) const
 
748
  {
 
749
    if (!(start == rhs.start))
 
750
      return false;
 
751
    if (!(finish == rhs.finish))
 
752
      return false;
 
753
    if (!(reversed == rhs.reversed))
 
754
      return false;
 
755
    if (!(count == rhs.count))
 
756
      return false;
 
757
    return true;
 
758
  }
 
759
  bool operator != (const SliceRange &rhs) const {
 
760
    return !(*this == rhs);
 
761
  }
 
762
 
 
763
  bool operator < (const SliceRange & ) const;
 
764
 
 
765
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
766
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
767
 
 
768
};
 
769
 
 
770
void swap(SliceRange &a, SliceRange &b);
 
771
 
 
772
typedef struct _SlicePredicate__isset {
 
773
  _SlicePredicate__isset() : column_names(false), slice_range(false) {}
 
774
  bool column_names;
 
775
  bool slice_range;
 
776
} _SlicePredicate__isset;
 
777
 
 
778
class SlicePredicate {
 
779
 public:
 
780
 
 
781
  static const char* ascii_fingerprint; // = "F59D1D81C17DFFAF09988BF1C9CE5E27";
 
782
  static const uint8_t binary_fingerprint[16]; // = {0xF5,0x9D,0x1D,0x81,0xC1,0x7D,0xFF,0xAF,0x09,0x98,0x8B,0xF1,0xC9,0xCE,0x5E,0x27};
 
783
 
 
784
  SlicePredicate() {
 
785
  }
 
786
 
 
787
  virtual ~SlicePredicate() throw() {}
 
788
 
 
789
  std::vector<std::string>  column_names;
 
790
  SliceRange slice_range;
 
791
 
 
792
  _SlicePredicate__isset __isset;
 
793
 
 
794
  void __set_column_names(const std::vector<std::string> & val) {
 
795
    column_names = val;
 
796
    __isset.column_names = true;
 
797
  }
 
798
 
 
799
  void __set_slice_range(const SliceRange& val) {
 
800
    slice_range = val;
 
801
    __isset.slice_range = true;
 
802
  }
 
803
 
 
804
  bool operator == (const SlicePredicate & rhs) const
 
805
  {
 
806
    if (__isset.column_names != rhs.__isset.column_names)
 
807
      return false;
 
808
    else if (__isset.column_names && !(column_names == rhs.column_names))
 
809
      return false;
 
810
    if (__isset.slice_range != rhs.__isset.slice_range)
 
811
      return false;
 
812
    else if (__isset.slice_range && !(slice_range == rhs.slice_range))
 
813
      return false;
 
814
    return true;
 
815
  }
 
816
  bool operator != (const SlicePredicate &rhs) const {
 
817
    return !(*this == rhs);
 
818
  }
 
819
 
 
820
  bool operator < (const SlicePredicate & ) const;
 
821
 
 
822
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
823
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
824
 
 
825
};
 
826
 
 
827
void swap(SlicePredicate &a, SlicePredicate &b);
 
828
 
 
829
 
 
830
class IndexExpression {
 
831
 public:
 
832
 
 
833
  static const char* ascii_fingerprint; // = "D9F4CFE2F293A8B1052FD3031DD2C847";
 
834
  static const uint8_t binary_fingerprint[16]; // = {0xD9,0xF4,0xCF,0xE2,0xF2,0x93,0xA8,0xB1,0x05,0x2F,0xD3,0x03,0x1D,0xD2,0xC8,0x47};
 
835
 
 
836
  IndexExpression() : column_name(), op((IndexOperator::type)0), value() {
 
837
  }
 
838
 
 
839
  virtual ~IndexExpression() throw() {}
 
840
 
 
841
  std::string column_name;
 
842
  IndexOperator::type op;
 
843
  std::string value;
 
844
 
 
845
  void __set_column_name(const std::string& val) {
 
846
    column_name = val;
 
847
  }
 
848
 
 
849
  void __set_op(const IndexOperator::type val) {
 
850
    op = val;
 
851
  }
 
852
 
 
853
  void __set_value(const std::string& val) {
 
854
    value = val;
 
855
  }
 
856
 
 
857
  bool operator == (const IndexExpression & rhs) const
 
858
  {
 
859
    if (!(column_name == rhs.column_name))
 
860
      return false;
 
861
    if (!(op == rhs.op))
 
862
      return false;
 
863
    if (!(value == rhs.value))
 
864
      return false;
 
865
    return true;
 
866
  }
 
867
  bool operator != (const IndexExpression &rhs) const {
 
868
    return !(*this == rhs);
 
869
  }
 
870
 
 
871
  bool operator < (const IndexExpression & ) const;
 
872
 
 
873
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
874
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
875
 
 
876
};
 
877
 
 
878
void swap(IndexExpression &a, IndexExpression &b);
 
879
 
 
880
 
 
881
class IndexClause {
 
882
 public:
 
883
 
 
884
  static const char* ascii_fingerprint; // = "9B551B9AB86120B0EEA9005C77FD3C1F";
 
885
  static const uint8_t binary_fingerprint[16]; // = {0x9B,0x55,0x1B,0x9A,0xB8,0x61,0x20,0xB0,0xEE,0xA9,0x00,0x5C,0x77,0xFD,0x3C,0x1F};
 
886
 
 
887
  IndexClause() : start_key(), count(100) {
 
888
  }
 
889
 
 
890
  virtual ~IndexClause() throw() {}
 
891
 
 
892
  std::vector<IndexExpression>  expressions;
 
893
  std::string start_key;
 
894
  int32_t count;
 
895
 
 
896
  void __set_expressions(const std::vector<IndexExpression> & val) {
 
897
    expressions = val;
 
898
  }
 
899
 
 
900
  void __set_start_key(const std::string& val) {
 
901
    start_key = val;
 
902
  }
 
903
 
 
904
  void __set_count(const int32_t val) {
 
905
    count = val;
 
906
  }
 
907
 
 
908
  bool operator == (const IndexClause & rhs) const
 
909
  {
 
910
    if (!(expressions == rhs.expressions))
 
911
      return false;
 
912
    if (!(start_key == rhs.start_key))
 
913
      return false;
 
914
    if (!(count == rhs.count))
 
915
      return false;
 
916
    return true;
 
917
  }
 
918
  bool operator != (const IndexClause &rhs) const {
 
919
    return !(*this == rhs);
 
920
  }
 
921
 
 
922
  bool operator < (const IndexClause & ) const;
 
923
 
 
924
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
925
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
926
 
 
927
};
 
928
 
 
929
void swap(IndexClause &a, IndexClause &b);
 
930
 
 
931
typedef struct _KeyRange__isset {
 
932
  _KeyRange__isset() : start_key(false), end_key(false), start_token(false), end_token(false), row_filter(false) {}
 
933
  bool start_key;
 
934
  bool end_key;
 
935
  bool start_token;
 
936
  bool end_token;
 
937
  bool row_filter;
 
938
} _KeyRange__isset;
 
939
 
 
940
class KeyRange {
 
941
 public:
 
942
 
 
943
  static const char* ascii_fingerprint; // = "A6EC82FA0980B91C7C8EB013C61CA1B0";
 
944
  static const uint8_t binary_fingerprint[16]; // = {0xA6,0xEC,0x82,0xFA,0x09,0x80,0xB9,0x1C,0x7C,0x8E,0xB0,0x13,0xC6,0x1C,0xA1,0xB0};
 
945
 
 
946
  KeyRange() : start_key(), end_key(), start_token(), end_token(), count(100) {
 
947
  }
 
948
 
 
949
  virtual ~KeyRange() throw() {}
 
950
 
 
951
  std::string start_key;
 
952
  std::string end_key;
 
953
  std::string start_token;
 
954
  std::string end_token;
 
955
  std::vector<IndexExpression>  row_filter;
 
956
  int32_t count;
 
957
 
 
958
  _KeyRange__isset __isset;
 
959
 
 
960
  void __set_start_key(const std::string& val) {
 
961
    start_key = val;
 
962
    __isset.start_key = true;
 
963
  }
 
964
 
 
965
  void __set_end_key(const std::string& val) {
 
966
    end_key = val;
 
967
    __isset.end_key = true;
 
968
  }
 
969
 
 
970
  void __set_start_token(const std::string& val) {
 
971
    start_token = val;
 
972
    __isset.start_token = true;
 
973
  }
 
974
 
 
975
  void __set_end_token(const std::string& val) {
 
976
    end_token = val;
 
977
    __isset.end_token = true;
 
978
  }
 
979
 
 
980
  void __set_row_filter(const std::vector<IndexExpression> & val) {
 
981
    row_filter = val;
 
982
    __isset.row_filter = true;
 
983
  }
 
984
 
 
985
  void __set_count(const int32_t val) {
 
986
    count = val;
 
987
  }
 
988
 
 
989
  bool operator == (const KeyRange & rhs) const
 
990
  {
 
991
    if (__isset.start_key != rhs.__isset.start_key)
 
992
      return false;
 
993
    else if (__isset.start_key && !(start_key == rhs.start_key))
 
994
      return false;
 
995
    if (__isset.end_key != rhs.__isset.end_key)
 
996
      return false;
 
997
    else if (__isset.end_key && !(end_key == rhs.end_key))
 
998
      return false;
 
999
    if (__isset.start_token != rhs.__isset.start_token)
 
1000
      return false;
 
1001
    else if (__isset.start_token && !(start_token == rhs.start_token))
 
1002
      return false;
 
1003
    if (__isset.end_token != rhs.__isset.end_token)
 
1004
      return false;
 
1005
    else if (__isset.end_token && !(end_token == rhs.end_token))
 
1006
      return false;
 
1007
    if (__isset.row_filter != rhs.__isset.row_filter)
 
1008
      return false;
 
1009
    else if (__isset.row_filter && !(row_filter == rhs.row_filter))
 
1010
      return false;
 
1011
    if (!(count == rhs.count))
 
1012
      return false;
 
1013
    return true;
 
1014
  }
 
1015
  bool operator != (const KeyRange &rhs) const {
 
1016
    return !(*this == rhs);
 
1017
  }
 
1018
 
 
1019
  bool operator < (const KeyRange & ) const;
 
1020
 
 
1021
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
1022
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
1023
 
 
1024
};
 
1025
 
 
1026
void swap(KeyRange &a, KeyRange &b);
 
1027
 
 
1028
 
 
1029
class KeySlice {
 
1030
 public:
 
1031
 
 
1032
  static const char* ascii_fingerprint; // = "D1568675B0C135C909E3169B72A4DA3D";
 
1033
  static const uint8_t binary_fingerprint[16]; // = {0xD1,0x56,0x86,0x75,0xB0,0xC1,0x35,0xC9,0x09,0xE3,0x16,0x9B,0x72,0xA4,0xDA,0x3D};
 
1034
 
 
1035
  KeySlice() : key() {
 
1036
  }
 
1037
 
 
1038
  virtual ~KeySlice() throw() {}
 
1039
 
 
1040
  std::string key;
 
1041
  std::vector<ColumnOrSuperColumn>  columns;
 
1042
 
 
1043
  void __set_key(const std::string& val) {
 
1044
    key = val;
 
1045
  }
 
1046
 
 
1047
  void __set_columns(const std::vector<ColumnOrSuperColumn> & val) {
 
1048
    columns = val;
 
1049
  }
 
1050
 
 
1051
  bool operator == (const KeySlice & rhs) const
 
1052
  {
 
1053
    if (!(key == rhs.key))
 
1054
      return false;
 
1055
    if (!(columns == rhs.columns))
 
1056
      return false;
 
1057
    return true;
 
1058
  }
 
1059
  bool operator != (const KeySlice &rhs) const {
 
1060
    return !(*this == rhs);
 
1061
  }
 
1062
 
 
1063
  bool operator < (const KeySlice & ) const;
 
1064
 
 
1065
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
1066
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
1067
 
 
1068
};
 
1069
 
 
1070
void swap(KeySlice &a, KeySlice &b);
 
1071
 
 
1072
 
 
1073
class KeyCount {
 
1074
 public:
 
1075
 
 
1076
  static const char* ascii_fingerprint; // = "EEBC915CE44901401D881E6091423036";
 
1077
  static const uint8_t binary_fingerprint[16]; // = {0xEE,0xBC,0x91,0x5C,0xE4,0x49,0x01,0x40,0x1D,0x88,0x1E,0x60,0x91,0x42,0x30,0x36};
 
1078
 
 
1079
  KeyCount() : key(), count(0) {
 
1080
  }
 
1081
 
 
1082
  virtual ~KeyCount() throw() {}
 
1083
 
 
1084
  std::string key;
 
1085
  int32_t count;
 
1086
 
 
1087
  void __set_key(const std::string& val) {
 
1088
    key = val;
 
1089
  }
 
1090
 
 
1091
  void __set_count(const int32_t val) {
 
1092
    count = val;
 
1093
  }
 
1094
 
 
1095
  bool operator == (const KeyCount & rhs) const
 
1096
  {
 
1097
    if (!(key == rhs.key))
 
1098
      return false;
 
1099
    if (!(count == rhs.count))
 
1100
      return false;
 
1101
    return true;
 
1102
  }
 
1103
  bool operator != (const KeyCount &rhs) const {
 
1104
    return !(*this == rhs);
 
1105
  }
 
1106
 
 
1107
  bool operator < (const KeyCount & ) const;
 
1108
 
 
1109
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
1110
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
1111
 
 
1112
};
 
1113
 
 
1114
void swap(KeyCount &a, KeyCount &b);
 
1115
 
 
1116
typedef struct _Deletion__isset {
 
1117
  _Deletion__isset() : timestamp(false), super_column(false), predicate(false) {}
 
1118
  bool timestamp;
 
1119
  bool super_column;
 
1120
  bool predicate;
 
1121
} _Deletion__isset;
 
1122
 
 
1123
class Deletion {
 
1124
 public:
 
1125
 
 
1126
  static const char* ascii_fingerprint; // = "40F33ECF1C932CA77C2414C4E6C60CBE";
 
1127
  static const uint8_t binary_fingerprint[16]; // = {0x40,0xF3,0x3E,0xCF,0x1C,0x93,0x2C,0xA7,0x7C,0x24,0x14,0xC4,0xE6,0xC6,0x0C,0xBE};
 
1128
 
 
1129
  Deletion() : timestamp(0), super_column() {
 
1130
  }
 
1131
 
 
1132
  virtual ~Deletion() throw() {}
 
1133
 
 
1134
  int64_t timestamp;
 
1135
  std::string super_column;
 
1136
  SlicePredicate predicate;
 
1137
 
 
1138
  _Deletion__isset __isset;
 
1139
 
 
1140
  void __set_timestamp(const int64_t val) {
 
1141
    timestamp = val;
 
1142
    __isset.timestamp = true;
 
1143
  }
 
1144
 
 
1145
  void __set_super_column(const std::string& val) {
 
1146
    super_column = val;
 
1147
    __isset.super_column = true;
 
1148
  }
 
1149
 
 
1150
  void __set_predicate(const SlicePredicate& val) {
 
1151
    predicate = val;
 
1152
    __isset.predicate = true;
 
1153
  }
 
1154
 
 
1155
  bool operator == (const Deletion & rhs) const
 
1156
  {
 
1157
    if (__isset.timestamp != rhs.__isset.timestamp)
 
1158
      return false;
 
1159
    else if (__isset.timestamp && !(timestamp == rhs.timestamp))
 
1160
      return false;
 
1161
    if (__isset.super_column != rhs.__isset.super_column)
 
1162
      return false;
 
1163
    else if (__isset.super_column && !(super_column == rhs.super_column))
 
1164
      return false;
 
1165
    if (__isset.predicate != rhs.__isset.predicate)
 
1166
      return false;
 
1167
    else if (__isset.predicate && !(predicate == rhs.predicate))
 
1168
      return false;
 
1169
    return true;
 
1170
  }
 
1171
  bool operator != (const Deletion &rhs) const {
 
1172
    return !(*this == rhs);
 
1173
  }
 
1174
 
 
1175
  bool operator < (const Deletion & ) const;
 
1176
 
 
1177
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
1178
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
1179
 
 
1180
};
 
1181
 
 
1182
void swap(Deletion &a, Deletion &b);
 
1183
 
 
1184
typedef struct _Mutation__isset {
 
1185
  _Mutation__isset() : column_or_supercolumn(false), deletion(false) {}
 
1186
  bool column_or_supercolumn;
 
1187
  bool deletion;
 
1188
} _Mutation__isset;
 
1189
 
 
1190
class Mutation {
 
1191
 public:
 
1192
 
 
1193
  static const char* ascii_fingerprint; // = "E8B65DF3979C6868F80DF81F8E769E63";
 
1194
  static const uint8_t binary_fingerprint[16]; // = {0xE8,0xB6,0x5D,0xF3,0x97,0x9C,0x68,0x68,0xF8,0x0D,0xF8,0x1F,0x8E,0x76,0x9E,0x63};
 
1195
 
 
1196
  Mutation() {
 
1197
  }
 
1198
 
 
1199
  virtual ~Mutation() throw() {}
 
1200
 
 
1201
  ColumnOrSuperColumn column_or_supercolumn;
 
1202
  Deletion deletion;
 
1203
 
 
1204
  _Mutation__isset __isset;
 
1205
 
 
1206
  void __set_column_or_supercolumn(const ColumnOrSuperColumn& val) {
 
1207
    column_or_supercolumn = val;
 
1208
    __isset.column_or_supercolumn = true;
 
1209
  }
 
1210
 
 
1211
  void __set_deletion(const Deletion& val) {
 
1212
    deletion = val;
 
1213
    __isset.deletion = true;
 
1214
  }
 
1215
 
 
1216
  bool operator == (const Mutation & rhs) const
 
1217
  {
 
1218
    if (__isset.column_or_supercolumn != rhs.__isset.column_or_supercolumn)
 
1219
      return false;
 
1220
    else if (__isset.column_or_supercolumn && !(column_or_supercolumn == rhs.column_or_supercolumn))
 
1221
      return false;
 
1222
    if (__isset.deletion != rhs.__isset.deletion)
 
1223
      return false;
 
1224
    else if (__isset.deletion && !(deletion == rhs.deletion))
 
1225
      return false;
 
1226
    return true;
 
1227
  }
 
1228
  bool operator != (const Mutation &rhs) const {
 
1229
    return !(*this == rhs);
 
1230
  }
 
1231
 
 
1232
  bool operator < (const Mutation & ) const;
 
1233
 
 
1234
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
1235
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
1236
 
 
1237
};
 
1238
 
 
1239
void swap(Mutation &a, Mutation &b);
 
1240
 
 
1241
typedef struct _EndpointDetails__isset {
 
1242
  _EndpointDetails__isset() : host(false), datacenter(false), rack(false) {}
 
1243
  bool host;
 
1244
  bool datacenter;
 
1245
  bool rack;
 
1246
} _EndpointDetails__isset;
 
1247
 
 
1248
class EndpointDetails {
 
1249
 public:
 
1250
 
 
1251
  static const char* ascii_fingerprint; // = "F4A50F0EC638C7F66026F9B6678FD89B";
 
1252
  static const uint8_t binary_fingerprint[16]; // = {0xF4,0xA5,0x0F,0x0E,0xC6,0x38,0xC7,0xF6,0x60,0x26,0xF9,0xB6,0x67,0x8F,0xD8,0x9B};
 
1253
 
 
1254
  EndpointDetails() : host(), datacenter(), rack() {
 
1255
  }
 
1256
 
 
1257
  virtual ~EndpointDetails() throw() {}
 
1258
 
 
1259
  std::string host;
 
1260
  std::string datacenter;
 
1261
  std::string rack;
 
1262
 
 
1263
  _EndpointDetails__isset __isset;
 
1264
 
 
1265
  void __set_host(const std::string& val) {
 
1266
    host = val;
 
1267
  }
 
1268
 
 
1269
  void __set_datacenter(const std::string& val) {
 
1270
    datacenter = val;
 
1271
  }
 
1272
 
 
1273
  void __set_rack(const std::string& val) {
 
1274
    rack = val;
 
1275
    __isset.rack = true;
 
1276
  }
 
1277
 
 
1278
  bool operator == (const EndpointDetails & rhs) const
 
1279
  {
 
1280
    if (!(host == rhs.host))
 
1281
      return false;
 
1282
    if (!(datacenter == rhs.datacenter))
 
1283
      return false;
 
1284
    if (__isset.rack != rhs.__isset.rack)
 
1285
      return false;
 
1286
    else if (__isset.rack && !(rack == rhs.rack))
 
1287
      return false;
 
1288
    return true;
 
1289
  }
 
1290
  bool operator != (const EndpointDetails &rhs) const {
 
1291
    return !(*this == rhs);
 
1292
  }
 
1293
 
 
1294
  bool operator < (const EndpointDetails & ) const;
 
1295
 
 
1296
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
1297
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
1298
 
 
1299
};
 
1300
 
 
1301
void swap(EndpointDetails &a, EndpointDetails &b);
 
1302
 
 
1303
typedef struct _TokenRange__isset {
 
1304
  _TokenRange__isset() : rpc_endpoints(false), endpoint_details(false) {}
 
1305
  bool rpc_endpoints;
 
1306
  bool endpoint_details;
 
1307
} _TokenRange__isset;
 
1308
 
 
1309
class TokenRange {
 
1310
 public:
 
1311
 
 
1312
  static const char* ascii_fingerprint; // = "832268DC4CD6B17EE8881FC57EA04679";
 
1313
  static const uint8_t binary_fingerprint[16]; // = {0x83,0x22,0x68,0xDC,0x4C,0xD6,0xB1,0x7E,0xE8,0x88,0x1F,0xC5,0x7E,0xA0,0x46,0x79};
 
1314
 
 
1315
  TokenRange() : start_token(), end_token() {
 
1316
  }
 
1317
 
 
1318
  virtual ~TokenRange() throw() {}
 
1319
 
 
1320
  std::string start_token;
 
1321
  std::string end_token;
 
1322
  std::vector<std::string>  endpoints;
 
1323
  std::vector<std::string>  rpc_endpoints;
 
1324
  std::vector<EndpointDetails>  endpoint_details;
 
1325
 
 
1326
  _TokenRange__isset __isset;
 
1327
 
 
1328
  void __set_start_token(const std::string& val) {
 
1329
    start_token = val;
 
1330
  }
 
1331
 
 
1332
  void __set_end_token(const std::string& val) {
 
1333
    end_token = val;
 
1334
  }
 
1335
 
 
1336
  void __set_endpoints(const std::vector<std::string> & val) {
 
1337
    endpoints = val;
 
1338
  }
 
1339
 
 
1340
  void __set_rpc_endpoints(const std::vector<std::string> & val) {
 
1341
    rpc_endpoints = val;
 
1342
    __isset.rpc_endpoints = true;
 
1343
  }
 
1344
 
 
1345
  void __set_endpoint_details(const std::vector<EndpointDetails> & val) {
 
1346
    endpoint_details = val;
 
1347
    __isset.endpoint_details = true;
 
1348
  }
 
1349
 
 
1350
  bool operator == (const TokenRange & rhs) const
 
1351
  {
 
1352
    if (!(start_token == rhs.start_token))
 
1353
      return false;
 
1354
    if (!(end_token == rhs.end_token))
 
1355
      return false;
 
1356
    if (!(endpoints == rhs.endpoints))
 
1357
      return false;
 
1358
    if (__isset.rpc_endpoints != rhs.__isset.rpc_endpoints)
 
1359
      return false;
 
1360
    else if (__isset.rpc_endpoints && !(rpc_endpoints == rhs.rpc_endpoints))
 
1361
      return false;
 
1362
    if (__isset.endpoint_details != rhs.__isset.endpoint_details)
 
1363
      return false;
 
1364
    else if (__isset.endpoint_details && !(endpoint_details == rhs.endpoint_details))
 
1365
      return false;
 
1366
    return true;
 
1367
  }
 
1368
  bool operator != (const TokenRange &rhs) const {
 
1369
    return !(*this == rhs);
 
1370
  }
 
1371
 
 
1372
  bool operator < (const TokenRange & ) const;
 
1373
 
 
1374
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
1375
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
1376
 
 
1377
};
 
1378
 
 
1379
void swap(TokenRange &a, TokenRange &b);
 
1380
 
 
1381
 
 
1382
class AuthenticationRequest {
 
1383
 public:
 
1384
 
 
1385
  static const char* ascii_fingerprint; // = "5EA2D527ECA3BA20C77AFC023EE8C05F";
 
1386
  static const uint8_t binary_fingerprint[16]; // = {0x5E,0xA2,0xD5,0x27,0xEC,0xA3,0xBA,0x20,0xC7,0x7A,0xFC,0x02,0x3E,0xE8,0xC0,0x5F};
 
1387
 
 
1388
  AuthenticationRequest() {
 
1389
  }
 
1390
 
 
1391
  virtual ~AuthenticationRequest() throw() {}
 
1392
 
 
1393
  std::map<std::string, std::string>  credentials;
 
1394
 
 
1395
  void __set_credentials(const std::map<std::string, std::string> & val) {
 
1396
    credentials = val;
 
1397
  }
 
1398
 
 
1399
  bool operator == (const AuthenticationRequest & rhs) const
 
1400
  {
 
1401
    if (!(credentials == rhs.credentials))
 
1402
      return false;
 
1403
    return true;
 
1404
  }
 
1405
  bool operator != (const AuthenticationRequest &rhs) const {
 
1406
    return !(*this == rhs);
 
1407
  }
 
1408
 
 
1409
  bool operator < (const AuthenticationRequest & ) const;
 
1410
 
 
1411
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
1412
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
1413
 
 
1414
};
 
1415
 
 
1416
void swap(AuthenticationRequest &a, AuthenticationRequest &b);
 
1417
 
 
1418
typedef struct _ColumnDef__isset {
 
1419
  _ColumnDef__isset() : index_type(false), index_name(false), index_options(false) {}
 
1420
  bool index_type;
 
1421
  bool index_name;
 
1422
  bool index_options;
 
1423
} _ColumnDef__isset;
 
1424
 
 
1425
class ColumnDef {
 
1426
 public:
 
1427
 
 
1428
  static const char* ascii_fingerprint; // = "0D89CE83D7EDAD079AC3213ED1DCAA58";
 
1429
  static const uint8_t binary_fingerprint[16]; // = {0x0D,0x89,0xCE,0x83,0xD7,0xED,0xAD,0x07,0x9A,0xC3,0x21,0x3E,0xD1,0xDC,0xAA,0x58};
 
1430
 
 
1431
  ColumnDef() : name(), validation_class(), index_type((IndexType::type)0), index_name() {
 
1432
  }
 
1433
 
 
1434
  virtual ~ColumnDef() throw() {}
 
1435
 
 
1436
  std::string name;
 
1437
  std::string validation_class;
 
1438
  IndexType::type index_type;
 
1439
  std::string index_name;
 
1440
  std::map<std::string, std::string>  index_options;
 
1441
 
 
1442
  _ColumnDef__isset __isset;
 
1443
 
 
1444
  void __set_name(const std::string& val) {
 
1445
    name = val;
 
1446
  }
 
1447
 
 
1448
  void __set_validation_class(const std::string& val) {
 
1449
    validation_class = val;
 
1450
  }
 
1451
 
 
1452
  void __set_index_type(const IndexType::type val) {
 
1453
    index_type = val;
 
1454
    __isset.index_type = true;
 
1455
  }
 
1456
 
 
1457
  void __set_index_name(const std::string& val) {
 
1458
    index_name = val;
 
1459
    __isset.index_name = true;
 
1460
  }
 
1461
 
 
1462
  void __set_index_options(const std::map<std::string, std::string> & val) {
 
1463
    index_options = val;
 
1464
    __isset.index_options = true;
 
1465
  }
 
1466
 
 
1467
  bool operator == (const ColumnDef & rhs) const
 
1468
  {
 
1469
    if (!(name == rhs.name))
 
1470
      return false;
 
1471
    if (!(validation_class == rhs.validation_class))
 
1472
      return false;
 
1473
    if (__isset.index_type != rhs.__isset.index_type)
 
1474
      return false;
 
1475
    else if (__isset.index_type && !(index_type == rhs.index_type))
 
1476
      return false;
 
1477
    if (__isset.index_name != rhs.__isset.index_name)
 
1478
      return false;
 
1479
    else if (__isset.index_name && !(index_name == rhs.index_name))
 
1480
      return false;
 
1481
    if (__isset.index_options != rhs.__isset.index_options)
 
1482
      return false;
 
1483
    else if (__isset.index_options && !(index_options == rhs.index_options))
 
1484
      return false;
 
1485
    return true;
 
1486
  }
 
1487
  bool operator != (const ColumnDef &rhs) const {
 
1488
    return !(*this == rhs);
 
1489
  }
 
1490
 
 
1491
  bool operator < (const ColumnDef & ) const;
 
1492
 
 
1493
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
1494
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
1495
 
 
1496
};
 
1497
 
 
1498
void swap(ColumnDef &a, ColumnDef &b);
 
1499
 
 
1500
typedef struct _CfDef__isset {
 
1501
  _CfDef__isset() : column_type(true), comparator_type(true), subcomparator_type(false), comment(false), read_repair_chance(false), column_metadata(false), gc_grace_seconds(false), default_validation_class(false), id(false), min_compaction_threshold(false), max_compaction_threshold(false), replicate_on_write(false), key_validation_class(false), key_alias(false), compaction_strategy(false), compaction_strategy_options(false), compression_options(false), bloom_filter_fp_chance(false), caching(true), dclocal_read_repair_chance(true), row_cache_size(false), key_cache_size(false), row_cache_save_period_in_seconds(false), key_cache_save_period_in_seconds(false), memtable_flush_after_mins(false), memtable_throughput_in_mb(false), memtable_operations_in_millions(false), merge_shards_chance(false), row_cache_provider(false), row_cache_keys_to_save(false) {}
 
1502
  bool column_type;
 
1503
  bool comparator_type;
 
1504
  bool subcomparator_type;
 
1505
  bool comment;
 
1506
  bool read_repair_chance;
 
1507
  bool column_metadata;
 
1508
  bool gc_grace_seconds;
 
1509
  bool default_validation_class;
 
1510
  bool id;
 
1511
  bool min_compaction_threshold;
 
1512
  bool max_compaction_threshold;
 
1513
  bool replicate_on_write;
 
1514
  bool key_validation_class;
 
1515
  bool key_alias;
 
1516
  bool compaction_strategy;
 
1517
  bool compaction_strategy_options;
 
1518
  bool compression_options;
 
1519
  bool bloom_filter_fp_chance;
 
1520
  bool caching;
 
1521
  bool dclocal_read_repair_chance;
 
1522
  bool row_cache_size;
 
1523
  bool key_cache_size;
 
1524
  bool row_cache_save_period_in_seconds;
 
1525
  bool key_cache_save_period_in_seconds;
 
1526
  bool memtable_flush_after_mins;
 
1527
  bool memtable_throughput_in_mb;
 
1528
  bool memtable_operations_in_millions;
 
1529
  bool merge_shards_chance;
 
1530
  bool row_cache_provider;
 
1531
  bool row_cache_keys_to_save;
 
1532
} _CfDef__isset;
 
1533
 
 
1534
class CfDef {
 
1535
 public:
 
1536
 
 
1537
  static const char* ascii_fingerprint; // = "231A260521B5DD99EFBCCBDD8768CA7D";
 
1538
  static const uint8_t binary_fingerprint[16]; // = {0x23,0x1A,0x26,0x05,0x21,0xB5,0xDD,0x99,0xEF,0xBC,0xCB,0xDD,0x87,0x68,0xCA,0x7D};
 
1539
 
 
1540
  CfDef() : keyspace(), name(), column_type("Standard"), comparator_type("BytesType"), subcomparator_type(), comment(), read_repair_chance(0), gc_grace_seconds(0), default_validation_class(), id(0), min_compaction_threshold(0), max_compaction_threshold(0), replicate_on_write(0), key_validation_class(), key_alias(), compaction_strategy(), bloom_filter_fp_chance(0), caching("keys_only"), dclocal_read_repair_chance(0), row_cache_size(0), key_cache_size(0), row_cache_save_period_in_seconds(0), key_cache_save_period_in_seconds(0), memtable_flush_after_mins(0), memtable_throughput_in_mb(0), memtable_operations_in_millions(0), merge_shards_chance(0), row_cache_provider(), row_cache_keys_to_save(0) {
 
1541
  }
 
1542
 
 
1543
  virtual ~CfDef() throw() {}
 
1544
 
 
1545
  std::string keyspace;
 
1546
  std::string name;
 
1547
  std::string column_type;
 
1548
  std::string comparator_type;
 
1549
  std::string subcomparator_type;
 
1550
  std::string comment;
 
1551
  double read_repair_chance;
 
1552
  std::vector<ColumnDef>  column_metadata;
 
1553
  int32_t gc_grace_seconds;
 
1554
  std::string default_validation_class;
 
1555
  int32_t id;
 
1556
  int32_t min_compaction_threshold;
 
1557
  int32_t max_compaction_threshold;
 
1558
  bool replicate_on_write;
 
1559
  std::string key_validation_class;
 
1560
  std::string key_alias;
 
1561
  std::string compaction_strategy;
 
1562
  std::map<std::string, std::string>  compaction_strategy_options;
 
1563
  std::map<std::string, std::string>  compression_options;
 
1564
  double bloom_filter_fp_chance;
 
1565
  std::string caching;
 
1566
  double dclocal_read_repair_chance;
 
1567
  double row_cache_size;
 
1568
  double key_cache_size;
 
1569
  int32_t row_cache_save_period_in_seconds;
 
1570
  int32_t key_cache_save_period_in_seconds;
 
1571
  int32_t memtable_flush_after_mins;
 
1572
  int32_t memtable_throughput_in_mb;
 
1573
  double memtable_operations_in_millions;
 
1574
  double merge_shards_chance;
 
1575
  std::string row_cache_provider;
 
1576
  int32_t row_cache_keys_to_save;
 
1577
 
 
1578
  _CfDef__isset __isset;
 
1579
 
 
1580
  void __set_keyspace(const std::string& val) {
 
1581
    keyspace = val;
 
1582
  }
 
1583
 
 
1584
  void __set_name(const std::string& val) {
 
1585
    name = val;
 
1586
  }
 
1587
 
 
1588
  void __set_column_type(const std::string& val) {
 
1589
    column_type = val;
 
1590
    __isset.column_type = true;
 
1591
  }
 
1592
 
 
1593
  void __set_comparator_type(const std::string& val) {
 
1594
    comparator_type = val;
 
1595
    __isset.comparator_type = true;
 
1596
  }
 
1597
 
 
1598
  void __set_subcomparator_type(const std::string& val) {
 
1599
    subcomparator_type = val;
 
1600
    __isset.subcomparator_type = true;
 
1601
  }
 
1602
 
 
1603
  void __set_comment(const std::string& val) {
 
1604
    comment = val;
 
1605
    __isset.comment = true;
 
1606
  }
 
1607
 
 
1608
  void __set_read_repair_chance(const double val) {
 
1609
    read_repair_chance = val;
 
1610
    __isset.read_repair_chance = true;
 
1611
  }
 
1612
 
 
1613
  void __set_column_metadata(const std::vector<ColumnDef> & val) {
 
1614
    column_metadata = val;
 
1615
    __isset.column_metadata = true;
 
1616
  }
 
1617
 
 
1618
  void __set_gc_grace_seconds(const int32_t val) {
 
1619
    gc_grace_seconds = val;
 
1620
    __isset.gc_grace_seconds = true;
 
1621
  }
 
1622
 
 
1623
  void __set_default_validation_class(const std::string& val) {
 
1624
    default_validation_class = val;
 
1625
    __isset.default_validation_class = true;
 
1626
  }
 
1627
 
 
1628
  void __set_id(const int32_t val) {
 
1629
    id = val;
 
1630
    __isset.id = true;
 
1631
  }
 
1632
 
 
1633
  void __set_min_compaction_threshold(const int32_t val) {
 
1634
    min_compaction_threshold = val;
 
1635
    __isset.min_compaction_threshold = true;
 
1636
  }
 
1637
 
 
1638
  void __set_max_compaction_threshold(const int32_t val) {
 
1639
    max_compaction_threshold = val;
 
1640
    __isset.max_compaction_threshold = true;
 
1641
  }
 
1642
 
 
1643
  void __set_replicate_on_write(const bool val) {
 
1644
    replicate_on_write = val;
 
1645
    __isset.replicate_on_write = true;
 
1646
  }
 
1647
 
 
1648
  void __set_key_validation_class(const std::string& val) {
 
1649
    key_validation_class = val;
 
1650
    __isset.key_validation_class = true;
 
1651
  }
 
1652
 
 
1653
  void __set_key_alias(const std::string& val) {
 
1654
    key_alias = val;
 
1655
    __isset.key_alias = true;
 
1656
  }
 
1657
 
 
1658
  void __set_compaction_strategy(const std::string& val) {
 
1659
    compaction_strategy = val;
 
1660
    __isset.compaction_strategy = true;
 
1661
  }
 
1662
 
 
1663
  void __set_compaction_strategy_options(const std::map<std::string, std::string> & val) {
 
1664
    compaction_strategy_options = val;
 
1665
    __isset.compaction_strategy_options = true;
 
1666
  }
 
1667
 
 
1668
  void __set_compression_options(const std::map<std::string, std::string> & val) {
 
1669
    compression_options = val;
 
1670
    __isset.compression_options = true;
 
1671
  }
 
1672
 
 
1673
  void __set_bloom_filter_fp_chance(const double val) {
 
1674
    bloom_filter_fp_chance = val;
 
1675
    __isset.bloom_filter_fp_chance = true;
 
1676
  }
 
1677
 
 
1678
  void __set_caching(const std::string& val) {
 
1679
    caching = val;
 
1680
    __isset.caching = true;
 
1681
  }
 
1682
 
 
1683
  void __set_dclocal_read_repair_chance(const double val) {
 
1684
    dclocal_read_repair_chance = val;
 
1685
    __isset.dclocal_read_repair_chance = true;
 
1686
  }
 
1687
 
 
1688
  void __set_row_cache_size(const double val) {
 
1689
    row_cache_size = val;
 
1690
    __isset.row_cache_size = true;
 
1691
  }
 
1692
 
 
1693
  void __set_key_cache_size(const double val) {
 
1694
    key_cache_size = val;
 
1695
    __isset.key_cache_size = true;
 
1696
  }
 
1697
 
 
1698
  void __set_row_cache_save_period_in_seconds(const int32_t val) {
 
1699
    row_cache_save_period_in_seconds = val;
 
1700
    __isset.row_cache_save_period_in_seconds = true;
 
1701
  }
 
1702
 
 
1703
  void __set_key_cache_save_period_in_seconds(const int32_t val) {
 
1704
    key_cache_save_period_in_seconds = val;
 
1705
    __isset.key_cache_save_period_in_seconds = true;
 
1706
  }
 
1707
 
 
1708
  void __set_memtable_flush_after_mins(const int32_t val) {
 
1709
    memtable_flush_after_mins = val;
 
1710
    __isset.memtable_flush_after_mins = true;
 
1711
  }
 
1712
 
 
1713
  void __set_memtable_throughput_in_mb(const int32_t val) {
 
1714
    memtable_throughput_in_mb = val;
 
1715
    __isset.memtable_throughput_in_mb = true;
 
1716
  }
 
1717
 
 
1718
  void __set_memtable_operations_in_millions(const double val) {
 
1719
    memtable_operations_in_millions = val;
 
1720
    __isset.memtable_operations_in_millions = true;
 
1721
  }
 
1722
 
 
1723
  void __set_merge_shards_chance(const double val) {
 
1724
    merge_shards_chance = val;
 
1725
    __isset.merge_shards_chance = true;
 
1726
  }
 
1727
 
 
1728
  void __set_row_cache_provider(const std::string& val) {
 
1729
    row_cache_provider = val;
 
1730
    __isset.row_cache_provider = true;
 
1731
  }
 
1732
 
 
1733
  void __set_row_cache_keys_to_save(const int32_t val) {
 
1734
    row_cache_keys_to_save = val;
 
1735
    __isset.row_cache_keys_to_save = true;
 
1736
  }
 
1737
 
 
1738
  bool operator == (const CfDef & rhs) const
 
1739
  {
 
1740
    if (!(keyspace == rhs.keyspace))
 
1741
      return false;
 
1742
    if (!(name == rhs.name))
 
1743
      return false;
 
1744
    if (__isset.column_type != rhs.__isset.column_type)
 
1745
      return false;
 
1746
    else if (__isset.column_type && !(column_type == rhs.column_type))
 
1747
      return false;
 
1748
    if (__isset.comparator_type != rhs.__isset.comparator_type)
 
1749
      return false;
 
1750
    else if (__isset.comparator_type && !(comparator_type == rhs.comparator_type))
 
1751
      return false;
 
1752
    if (__isset.subcomparator_type != rhs.__isset.subcomparator_type)
 
1753
      return false;
 
1754
    else if (__isset.subcomparator_type && !(subcomparator_type == rhs.subcomparator_type))
 
1755
      return false;
 
1756
    if (__isset.comment != rhs.__isset.comment)
 
1757
      return false;
 
1758
    else if (__isset.comment && !(comment == rhs.comment))
 
1759
      return false;
 
1760
    if (__isset.read_repair_chance != rhs.__isset.read_repair_chance)
 
1761
      return false;
 
1762
    else if (__isset.read_repair_chance && !(read_repair_chance == rhs.read_repair_chance))
 
1763
      return false;
 
1764
    if (__isset.column_metadata != rhs.__isset.column_metadata)
 
1765
      return false;
 
1766
    else if (__isset.column_metadata && !(column_metadata == rhs.column_metadata))
 
1767
      return false;
 
1768
    if (__isset.gc_grace_seconds != rhs.__isset.gc_grace_seconds)
 
1769
      return false;
 
1770
    else if (__isset.gc_grace_seconds && !(gc_grace_seconds == rhs.gc_grace_seconds))
 
1771
      return false;
 
1772
    if (__isset.default_validation_class != rhs.__isset.default_validation_class)
 
1773
      return false;
 
1774
    else if (__isset.default_validation_class && !(default_validation_class == rhs.default_validation_class))
 
1775
      return false;
 
1776
    if (__isset.id != rhs.__isset.id)
 
1777
      return false;
 
1778
    else if (__isset.id && !(id == rhs.id))
 
1779
      return false;
 
1780
    if (__isset.min_compaction_threshold != rhs.__isset.min_compaction_threshold)
 
1781
      return false;
 
1782
    else if (__isset.min_compaction_threshold && !(min_compaction_threshold == rhs.min_compaction_threshold))
 
1783
      return false;
 
1784
    if (__isset.max_compaction_threshold != rhs.__isset.max_compaction_threshold)
 
1785
      return false;
 
1786
    else if (__isset.max_compaction_threshold && !(max_compaction_threshold == rhs.max_compaction_threshold))
 
1787
      return false;
 
1788
    if (__isset.replicate_on_write != rhs.__isset.replicate_on_write)
 
1789
      return false;
 
1790
    else if (__isset.replicate_on_write && !(replicate_on_write == rhs.replicate_on_write))
 
1791
      return false;
 
1792
    if (__isset.key_validation_class != rhs.__isset.key_validation_class)
 
1793
      return false;
 
1794
    else if (__isset.key_validation_class && !(key_validation_class == rhs.key_validation_class))
 
1795
      return false;
 
1796
    if (__isset.key_alias != rhs.__isset.key_alias)
 
1797
      return false;
 
1798
    else if (__isset.key_alias && !(key_alias == rhs.key_alias))
 
1799
      return false;
 
1800
    if (__isset.compaction_strategy != rhs.__isset.compaction_strategy)
 
1801
      return false;
 
1802
    else if (__isset.compaction_strategy && !(compaction_strategy == rhs.compaction_strategy))
 
1803
      return false;
 
1804
    if (__isset.compaction_strategy_options != rhs.__isset.compaction_strategy_options)
 
1805
      return false;
 
1806
    else if (__isset.compaction_strategy_options && !(compaction_strategy_options == rhs.compaction_strategy_options))
 
1807
      return false;
 
1808
    if (__isset.compression_options != rhs.__isset.compression_options)
 
1809
      return false;
 
1810
    else if (__isset.compression_options && !(compression_options == rhs.compression_options))
 
1811
      return false;
 
1812
    if (__isset.bloom_filter_fp_chance != rhs.__isset.bloom_filter_fp_chance)
 
1813
      return false;
 
1814
    else if (__isset.bloom_filter_fp_chance && !(bloom_filter_fp_chance == rhs.bloom_filter_fp_chance))
 
1815
      return false;
 
1816
    if (__isset.caching != rhs.__isset.caching)
 
1817
      return false;
 
1818
    else if (__isset.caching && !(caching == rhs.caching))
 
1819
      return false;
 
1820
    if (__isset.dclocal_read_repair_chance != rhs.__isset.dclocal_read_repair_chance)
 
1821
      return false;
 
1822
    else if (__isset.dclocal_read_repair_chance && !(dclocal_read_repair_chance == rhs.dclocal_read_repair_chance))
 
1823
      return false;
 
1824
    if (__isset.row_cache_size != rhs.__isset.row_cache_size)
 
1825
      return false;
 
1826
    else if (__isset.row_cache_size && !(row_cache_size == rhs.row_cache_size))
 
1827
      return false;
 
1828
    if (__isset.key_cache_size != rhs.__isset.key_cache_size)
 
1829
      return false;
 
1830
    else if (__isset.key_cache_size && !(key_cache_size == rhs.key_cache_size))
 
1831
      return false;
 
1832
    if (__isset.row_cache_save_period_in_seconds != rhs.__isset.row_cache_save_period_in_seconds)
 
1833
      return false;
 
1834
    else if (__isset.row_cache_save_period_in_seconds && !(row_cache_save_period_in_seconds == rhs.row_cache_save_period_in_seconds))
 
1835
      return false;
 
1836
    if (__isset.key_cache_save_period_in_seconds != rhs.__isset.key_cache_save_period_in_seconds)
 
1837
      return false;
 
1838
    else if (__isset.key_cache_save_period_in_seconds && !(key_cache_save_period_in_seconds == rhs.key_cache_save_period_in_seconds))
 
1839
      return false;
 
1840
    if (__isset.memtable_flush_after_mins != rhs.__isset.memtable_flush_after_mins)
 
1841
      return false;
 
1842
    else if (__isset.memtable_flush_after_mins && !(memtable_flush_after_mins == rhs.memtable_flush_after_mins))
 
1843
      return false;
 
1844
    if (__isset.memtable_throughput_in_mb != rhs.__isset.memtable_throughput_in_mb)
 
1845
      return false;
 
1846
    else if (__isset.memtable_throughput_in_mb && !(memtable_throughput_in_mb == rhs.memtable_throughput_in_mb))
 
1847
      return false;
 
1848
    if (__isset.memtable_operations_in_millions != rhs.__isset.memtable_operations_in_millions)
 
1849
      return false;
 
1850
    else if (__isset.memtable_operations_in_millions && !(memtable_operations_in_millions == rhs.memtable_operations_in_millions))
 
1851
      return false;
 
1852
    if (__isset.merge_shards_chance != rhs.__isset.merge_shards_chance)
 
1853
      return false;
 
1854
    else if (__isset.merge_shards_chance && !(merge_shards_chance == rhs.merge_shards_chance))
 
1855
      return false;
 
1856
    if (__isset.row_cache_provider != rhs.__isset.row_cache_provider)
 
1857
      return false;
 
1858
    else if (__isset.row_cache_provider && !(row_cache_provider == rhs.row_cache_provider))
 
1859
      return false;
 
1860
    if (__isset.row_cache_keys_to_save != rhs.__isset.row_cache_keys_to_save)
 
1861
      return false;
 
1862
    else if (__isset.row_cache_keys_to_save && !(row_cache_keys_to_save == rhs.row_cache_keys_to_save))
 
1863
      return false;
 
1864
    return true;
 
1865
  }
 
1866
  bool operator != (const CfDef &rhs) const {
 
1867
    return !(*this == rhs);
 
1868
  }
 
1869
 
 
1870
  bool operator < (const CfDef & ) const;
 
1871
 
 
1872
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
1873
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
1874
 
 
1875
};
 
1876
 
 
1877
void swap(CfDef &a, CfDef &b);
 
1878
 
 
1879
typedef struct _KsDef__isset {
 
1880
  _KsDef__isset() : strategy_options(false), replication_factor(false), durable_writes(true) {}
 
1881
  bool strategy_options;
 
1882
  bool replication_factor;
 
1883
  bool durable_writes;
 
1884
} _KsDef__isset;
 
1885
 
 
1886
class KsDef {
 
1887
 public:
 
1888
 
 
1889
  static const char* ascii_fingerprint; // = "0767851B6476EB3777A21E59E912E11A";
 
1890
  static const uint8_t binary_fingerprint[16]; // = {0x07,0x67,0x85,0x1B,0x64,0x76,0xEB,0x37,0x77,0xA2,0x1E,0x59,0xE9,0x12,0xE1,0x1A};
 
1891
 
 
1892
  KsDef() : name(), strategy_class(), replication_factor(0), durable_writes(true) {
 
1893
  }
 
1894
 
 
1895
  virtual ~KsDef() throw() {}
 
1896
 
 
1897
  std::string name;
 
1898
  std::string strategy_class;
 
1899
  std::map<std::string, std::string>  strategy_options;
 
1900
  int32_t replication_factor;
 
1901
  std::vector<CfDef>  cf_defs;
 
1902
  bool durable_writes;
 
1903
 
 
1904
  _KsDef__isset __isset;
 
1905
 
 
1906
  void __set_name(const std::string& val) {
 
1907
    name = val;
 
1908
  }
 
1909
 
 
1910
  void __set_strategy_class(const std::string& val) {
 
1911
    strategy_class = val;
 
1912
  }
 
1913
 
 
1914
  void __set_strategy_options(const std::map<std::string, std::string> & val) {
 
1915
    strategy_options = val;
 
1916
    __isset.strategy_options = true;
 
1917
  }
 
1918
 
 
1919
  void __set_replication_factor(const int32_t val) {
 
1920
    replication_factor = val;
 
1921
    __isset.replication_factor = true;
 
1922
  }
 
1923
 
 
1924
  void __set_cf_defs(const std::vector<CfDef> & val) {
 
1925
    cf_defs = val;
 
1926
  }
 
1927
 
 
1928
  void __set_durable_writes(const bool val) {
 
1929
    durable_writes = val;
 
1930
    __isset.durable_writes = true;
 
1931
  }
 
1932
 
 
1933
  bool operator == (const KsDef & rhs) const
 
1934
  {
 
1935
    if (!(name == rhs.name))
 
1936
      return false;
 
1937
    if (!(strategy_class == rhs.strategy_class))
 
1938
      return false;
 
1939
    if (__isset.strategy_options != rhs.__isset.strategy_options)
 
1940
      return false;
 
1941
    else if (__isset.strategy_options && !(strategy_options == rhs.strategy_options))
 
1942
      return false;
 
1943
    if (__isset.replication_factor != rhs.__isset.replication_factor)
 
1944
      return false;
 
1945
    else if (__isset.replication_factor && !(replication_factor == rhs.replication_factor))
 
1946
      return false;
 
1947
    if (!(cf_defs == rhs.cf_defs))
 
1948
      return false;
 
1949
    if (__isset.durable_writes != rhs.__isset.durable_writes)
 
1950
      return false;
 
1951
    else if (__isset.durable_writes && !(durable_writes == rhs.durable_writes))
 
1952
      return false;
 
1953
    return true;
 
1954
  }
 
1955
  bool operator != (const KsDef &rhs) const {
 
1956
    return !(*this == rhs);
 
1957
  }
 
1958
 
 
1959
  bool operator < (const KsDef & ) const;
 
1960
 
 
1961
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
1962
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
1963
 
 
1964
};
 
1965
 
 
1966
void swap(KsDef &a, KsDef &b);
 
1967
 
 
1968
 
 
1969
class CqlRow {
 
1970
 public:
 
1971
 
 
1972
  static const char* ascii_fingerprint; // = "470EFC558004E98D92D604898305C04E";
 
1973
  static const uint8_t binary_fingerprint[16]; // = {0x47,0x0E,0xFC,0x55,0x80,0x04,0xE9,0x8D,0x92,0xD6,0x04,0x89,0x83,0x05,0xC0,0x4E};
 
1974
 
 
1975
  CqlRow() : key() {
 
1976
  }
 
1977
 
 
1978
  virtual ~CqlRow() throw() {}
 
1979
 
 
1980
  std::string key;
 
1981
  std::vector<Column>  columns;
 
1982
 
 
1983
  void __set_key(const std::string& val) {
 
1984
    key = val;
 
1985
  }
 
1986
 
 
1987
  void __set_columns(const std::vector<Column> & val) {
 
1988
    columns = val;
 
1989
  }
 
1990
 
 
1991
  bool operator == (const CqlRow & rhs) const
 
1992
  {
 
1993
    if (!(key == rhs.key))
 
1994
      return false;
 
1995
    if (!(columns == rhs.columns))
 
1996
      return false;
 
1997
    return true;
 
1998
  }
 
1999
  bool operator != (const CqlRow &rhs) const {
 
2000
    return !(*this == rhs);
 
2001
  }
 
2002
 
 
2003
  bool operator < (const CqlRow & ) const;
 
2004
 
 
2005
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
2006
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
2007
 
 
2008
};
 
2009
 
 
2010
void swap(CqlRow &a, CqlRow &b);
 
2011
 
 
2012
 
 
2013
class CqlMetadata {
 
2014
 public:
 
2015
 
 
2016
  static const char* ascii_fingerprint; // = "B7C5A4AA9652C744A48EBC1C12D531E7";
 
2017
  static const uint8_t binary_fingerprint[16]; // = {0xB7,0xC5,0xA4,0xAA,0x96,0x52,0xC7,0x44,0xA4,0x8E,0xBC,0x1C,0x12,0xD5,0x31,0xE7};
 
2018
 
 
2019
  CqlMetadata() : default_name_type(), default_value_type() {
 
2020
  }
 
2021
 
 
2022
  virtual ~CqlMetadata() throw() {}
 
2023
 
 
2024
  std::map<std::string, std::string>  name_types;
 
2025
  std::map<std::string, std::string>  value_types;
 
2026
  std::string default_name_type;
 
2027
  std::string default_value_type;
 
2028
 
 
2029
  void __set_name_types(const std::map<std::string, std::string> & val) {
 
2030
    name_types = val;
 
2031
  }
 
2032
 
 
2033
  void __set_value_types(const std::map<std::string, std::string> & val) {
 
2034
    value_types = val;
 
2035
  }
 
2036
 
 
2037
  void __set_default_name_type(const std::string& val) {
 
2038
    default_name_type = val;
 
2039
  }
 
2040
 
 
2041
  void __set_default_value_type(const std::string& val) {
 
2042
    default_value_type = val;
 
2043
  }
 
2044
 
 
2045
  bool operator == (const CqlMetadata & rhs) const
 
2046
  {
 
2047
    if (!(name_types == rhs.name_types))
 
2048
      return false;
 
2049
    if (!(value_types == rhs.value_types))
 
2050
      return false;
 
2051
    if (!(default_name_type == rhs.default_name_type))
 
2052
      return false;
 
2053
    if (!(default_value_type == rhs.default_value_type))
 
2054
      return false;
 
2055
    return true;
 
2056
  }
 
2057
  bool operator != (const CqlMetadata &rhs) const {
 
2058
    return !(*this == rhs);
 
2059
  }
 
2060
 
 
2061
  bool operator < (const CqlMetadata & ) const;
 
2062
 
 
2063
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
2064
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
2065
 
 
2066
};
 
2067
 
 
2068
void swap(CqlMetadata &a, CqlMetadata &b);
 
2069
 
 
2070
typedef struct _CqlResult__isset {
 
2071
  _CqlResult__isset() : rows(false), num(false), schema(false) {}
 
2072
  bool rows;
 
2073
  bool num;
 
2074
  bool schema;
 
2075
} _CqlResult__isset;
 
2076
 
 
2077
class CqlResult {
 
2078
 public:
 
2079
 
 
2080
  static const char* ascii_fingerprint; // = "521B9CE5AF77539F7267F6952B609E81";
 
2081
  static const uint8_t binary_fingerprint[16]; // = {0x52,0x1B,0x9C,0xE5,0xAF,0x77,0x53,0x9F,0x72,0x67,0xF6,0x95,0x2B,0x60,0x9E,0x81};
 
2082
 
 
2083
  CqlResult() : type((CqlResultType::type)0), num(0) {
 
2084
  }
 
2085
 
 
2086
  virtual ~CqlResult() throw() {}
 
2087
 
 
2088
  CqlResultType::type type;
 
2089
  std::vector<CqlRow>  rows;
 
2090
  int32_t num;
 
2091
  CqlMetadata schema;
 
2092
 
 
2093
  _CqlResult__isset __isset;
 
2094
 
 
2095
  void __set_type(const CqlResultType::type val) {
 
2096
    type = val;
 
2097
  }
 
2098
 
 
2099
  void __set_rows(const std::vector<CqlRow> & val) {
 
2100
    rows = val;
 
2101
    __isset.rows = true;
 
2102
  }
 
2103
 
 
2104
  void __set_num(const int32_t val) {
 
2105
    num = val;
 
2106
    __isset.num = true;
 
2107
  }
 
2108
 
 
2109
  void __set_schema(const CqlMetadata& val) {
 
2110
    schema = val;
 
2111
    __isset.schema = true;
 
2112
  }
 
2113
 
 
2114
  bool operator == (const CqlResult & rhs) const
 
2115
  {
 
2116
    if (!(type == rhs.type))
 
2117
      return false;
 
2118
    if (__isset.rows != rhs.__isset.rows)
 
2119
      return false;
 
2120
    else if (__isset.rows && !(rows == rhs.rows))
 
2121
      return false;
 
2122
    if (__isset.num != rhs.__isset.num)
 
2123
      return false;
 
2124
    else if (__isset.num && !(num == rhs.num))
 
2125
      return false;
 
2126
    if (__isset.schema != rhs.__isset.schema)
 
2127
      return false;
 
2128
    else if (__isset.schema && !(schema == rhs.schema))
 
2129
      return false;
 
2130
    return true;
 
2131
  }
 
2132
  bool operator != (const CqlResult &rhs) const {
 
2133
    return !(*this == rhs);
 
2134
  }
 
2135
 
 
2136
  bool operator < (const CqlResult & ) const;
 
2137
 
 
2138
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
2139
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
2140
 
 
2141
};
 
2142
 
 
2143
void swap(CqlResult &a, CqlResult &b);
 
2144
 
 
2145
typedef struct _CqlPreparedResult__isset {
 
2146
  _CqlPreparedResult__isset() : variable_types(false), variable_names(false) {}
 
2147
  bool variable_types;
 
2148
  bool variable_names;
 
2149
} _CqlPreparedResult__isset;
 
2150
 
 
2151
class CqlPreparedResult {
 
2152
 public:
 
2153
 
 
2154
  static const char* ascii_fingerprint; // = "7E1663EC688DFDC28722BF36F9F64E6F";
 
2155
  static const uint8_t binary_fingerprint[16]; // = {0x7E,0x16,0x63,0xEC,0x68,0x8D,0xFD,0xC2,0x87,0x22,0xBF,0x36,0xF9,0xF6,0x4E,0x6F};
 
2156
 
 
2157
  CqlPreparedResult() : itemId(0), count(0) {
 
2158
  }
 
2159
 
 
2160
  virtual ~CqlPreparedResult() throw() {}
 
2161
 
 
2162
  int32_t itemId;
 
2163
  int32_t count;
 
2164
  std::vector<std::string>  variable_types;
 
2165
  std::vector<std::string>  variable_names;
 
2166
 
 
2167
  _CqlPreparedResult__isset __isset;
 
2168
 
 
2169
  void __set_itemId(const int32_t val) {
 
2170
    itemId = val;
 
2171
  }
 
2172
 
 
2173
  void __set_count(const int32_t val) {
 
2174
    count = val;
 
2175
  }
 
2176
 
 
2177
  void __set_variable_types(const std::vector<std::string> & val) {
 
2178
    variable_types = val;
 
2179
    __isset.variable_types = true;
 
2180
  }
 
2181
 
 
2182
  void __set_variable_names(const std::vector<std::string> & val) {
 
2183
    variable_names = val;
 
2184
    __isset.variable_names = true;
 
2185
  }
 
2186
 
 
2187
  bool operator == (const CqlPreparedResult & rhs) const
 
2188
  {
 
2189
    if (!(itemId == rhs.itemId))
 
2190
      return false;
 
2191
    if (!(count == rhs.count))
 
2192
      return false;
 
2193
    if (__isset.variable_types != rhs.__isset.variable_types)
 
2194
      return false;
 
2195
    else if (__isset.variable_types && !(variable_types == rhs.variable_types))
 
2196
      return false;
 
2197
    if (__isset.variable_names != rhs.__isset.variable_names)
 
2198
      return false;
 
2199
    else if (__isset.variable_names && !(variable_names == rhs.variable_names))
 
2200
      return false;
 
2201
    return true;
 
2202
  }
 
2203
  bool operator != (const CqlPreparedResult &rhs) const {
 
2204
    return !(*this == rhs);
 
2205
  }
 
2206
 
 
2207
  bool operator < (const CqlPreparedResult & ) const;
 
2208
 
 
2209
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
2210
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
2211
 
 
2212
};
 
2213
 
 
2214
void swap(CqlPreparedResult &a, CqlPreparedResult &b);
 
2215
 
 
2216
}}} // namespace
 
2217
 
 
2218
#endif