Browse code

core, lib, modules: restructured source code tree

- new folder src/ to hold the source code for main project applications
- main.c is in src/
- all core files are subfolder are in src/core/
- modules are in src/modules/
- libs are in src/lib/
- application Makefiles are in src/
- application binary is built in src/ (src/kamailio)

Daniel-Constantin Mierla authored on 07/12/2016 11:03:51
Showing 1 changed files
1 1
new file mode 100644
... ...
@@ -0,0 +1,1520 @@
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_TYPES_H
7
+#define cassandra_TYPES_H
8
+
9
+#include <Thrift.h>
10
+#include <TApplicationException.h>
11
+#include <protocol/TProtocol.h>
12
+#include <transport/TTransport.h>
13
+
14
+
15
+
16
+namespace org { namespace apache { namespace cassandra {
17
+
18
+struct ConsistencyLevel {
19
+  enum type {
20
+    ONE = 1,
21
+    QUORUM = 2,
22
+    LOCAL_QUORUM = 3,
23
+    EACH_QUORUM = 4,
24
+    ALL = 5,
25
+    ANY = 6,
26
+    TWO = 7,
27
+    THREE = 8
28
+  };
29
+};
30
+
31
+extern const std::map<int, const char*> _ConsistencyLevel_VALUES_TO_NAMES;
32
+
33
+struct IndexOperator {
34
+  enum type {
35
+    EQ = 0,
36
+    GTE = 1,
37
+    GT = 2,
38
+    LTE = 3,
39
+    LT = 4
40
+  };
41
+};
42
+
43
+extern const std::map<int, const char*> _IndexOperator_VALUES_TO_NAMES;
44
+
45
+struct IndexType {
46
+  enum type {
47
+    KEYS = 0,
48
+    CUSTOM = 1
49
+  };
50
+};
51
+
52
+extern const std::map<int, const char*> _IndexType_VALUES_TO_NAMES;
53
+
54
+struct Compression {
55
+  enum type {
56
+    GZIP = 1,
57
+    NONE = 2
58
+  };
59
+};
60
+
61
+extern const std::map<int, const char*> _Compression_VALUES_TO_NAMES;
62
+
63
+struct CqlResultType {
64
+  enum type {
65
+    ROWS = 1,
66
+    VOID = 2,
67
+    INT = 3
68
+  };
69
+};
70
+
71
+extern const std::map<int, const char*> _CqlResultType_VALUES_TO_NAMES;
72
+
73
+typedef struct _Column__isset {
74
+  _Column__isset() : value(false), timestamp(false), ttl(false) {}
75
+  bool value;
76
+  bool timestamp;
77
+  bool ttl;
78
+} _Column__isset;
79
+
80
+class Column {
81
+ public:
82
+
83
+  static const char* ascii_fingerprint; // = "3EE0E1C5C844001B62F08125068292CC";
84
+  static const uint8_t binary_fingerprint[16]; // = {0x3E,0xE0,0xE1,0xC5,0xC8,0x44,0x00,0x1B,0x62,0xF0,0x81,0x25,0x06,0x82,0x92,0xCC};
85
+
86
+  Column() : name(""), value(""), timestamp(0), ttl(0) {
87
+  }
88
+
89
+  virtual ~Column() throw() {}
90
+
91
+  std::string name;
92
+  std::string value;
93
+  int64_t timestamp;
94
+  int32_t ttl;
95
+
96
+  _Column__isset __isset;
97
+
98
+  bool operator == (const Column & rhs) const
99
+  {
100
+    if (!(name == rhs.name))
101
+      return false;
102
+    if (__isset.value != rhs.__isset.value)
103
+      return false;
104
+    else if (__isset.value && !(value == rhs.value))
105
+      return false;
106
+    if (__isset.timestamp != rhs.__isset.timestamp)
107
+      return false;
108
+    else if (__isset.timestamp && !(timestamp == rhs.timestamp))
109
+      return false;
110
+    if (__isset.ttl != rhs.__isset.ttl)
111
+      return false;
112
+    else if (__isset.ttl && !(ttl == rhs.ttl))
113
+      return false;
114
+    return true;
115
+  }
116
+  bool operator != (const Column &rhs) const {
117
+    return !(*this == rhs);
118
+  }
119
+
120
+  bool operator < (const Column & ) const;
121
+
122
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
123
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
124
+
125
+};
126
+
127
+
128
+class SuperColumn {
129
+ public:
130
+
131
+  static const char* ascii_fingerprint; // = "470EFC558004E98D92D604898305C04E";
132
+  static const uint8_t binary_fingerprint[16]; // = {0x47,0x0E,0xFC,0x55,0x80,0x04,0xE9,0x8D,0x92,0xD6,0x04,0x89,0x83,0x05,0xC0,0x4E};
133
+
134
+  SuperColumn() : name("") {
135
+  }
136
+
137
+  virtual ~SuperColumn() throw() {}
138
+
139
+  std::string name;
140
+  std::vector<Column>  columns;
141
+
142
+  bool operator == (const SuperColumn & rhs) const
143
+  {
144
+    if (!(name == rhs.name))
145
+      return false;
146
+    if (!(columns == rhs.columns))
147
+      return false;
148
+    return true;
149
+  }
150
+  bool operator != (const SuperColumn &rhs) const {
151
+    return !(*this == rhs);
152
+  }
153
+
154
+  bool operator < (const SuperColumn & ) const;
155
+
156
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
157
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
158
+
159
+};
160
+
161
+
162
+class CounterColumn {
163
+ public:
164
+
165
+  static const char* ascii_fingerprint; // = "1CCCF6FC31CFD1D61BBBB1BAF3590620";
166
+  static const uint8_t binary_fingerprint[16]; // = {0x1C,0xCC,0xF6,0xFC,0x31,0xCF,0xD1,0xD6,0x1B,0xBB,0xB1,0xBA,0xF3,0x59,0x06,0x20};
167
+
168
+  CounterColumn() : name(""), value(0) {
169
+  }
170
+
171
+  virtual ~CounterColumn() throw() {}
172
+
173
+  std::string name;
174
+  int64_t value;
175
+
176
+  bool operator == (const CounterColumn & rhs) const
177
+  {
178
+    if (!(name == rhs.name))
179
+      return false;
180
+    if (!(value == rhs.value))
181
+      return false;
182
+    return true;
183
+  }
184
+  bool operator != (const CounterColumn &rhs) const {
185
+    return !(*this == rhs);
186
+  }
187
+
188
+  bool operator < (const CounterColumn & ) const;
189
+
190
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
191
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
192
+
193
+};
194
+
195
+
196
+class CounterSuperColumn {
197
+ public:
198
+
199
+  static const char* ascii_fingerprint; // = "CD4C8C4BF7753E46DE417CDE369343A4";
200
+  static const uint8_t binary_fingerprint[16]; // = {0xCD,0x4C,0x8C,0x4B,0xF7,0x75,0x3E,0x46,0xDE,0x41,0x7C,0xDE,0x36,0x93,0x43,0xA4};
201
+
202
+  CounterSuperColumn() : name("") {
203
+  }
204
+
205
+  virtual ~CounterSuperColumn() throw() {}
206
+
207
+  std::string name;
208
+  std::vector<CounterColumn>  columns;
209
+
210
+  bool operator == (const CounterSuperColumn & rhs) const
211
+  {
212
+    if (!(name == rhs.name))
213
+      return false;
214
+    if (!(columns == rhs.columns))
215
+      return false;
216
+    return true;
217
+  }
218
+  bool operator != (const CounterSuperColumn &rhs) const {
219
+    return !(*this == rhs);
220
+  }
221
+
222
+  bool operator < (const CounterSuperColumn & ) const;
223
+
224
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
225
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
226
+
227
+};
228
+
229
+typedef struct _ColumnOrSuperColumn__isset {
230
+  _ColumnOrSuperColumn__isset() : column(false), super_column(false), counter_column(false), counter_super_column(false) {}
231
+  bool column;
232
+  bool super_column;
233
+  bool counter_column;
234
+  bool counter_super_column;
235
+} _ColumnOrSuperColumn__isset;
236
+
237
+class ColumnOrSuperColumn {
238
+ public:
239
+
240
+  static const char* ascii_fingerprint; // = "2B34AC9E80F1DAA3A2A63B1AB1841E61";
241
+  static const uint8_t binary_fingerprint[16]; // = {0x2B,0x34,0xAC,0x9E,0x80,0xF1,0xDA,0xA3,0xA2,0xA6,0x3B,0x1A,0xB1,0x84,0x1E,0x61};
242
+
243
+  ColumnOrSuperColumn() {
244
+  }
245
+
246
+  virtual ~ColumnOrSuperColumn() throw() {}
247
+
248
+  Column column;
249
+  SuperColumn super_column;
250
+  CounterColumn counter_column;
251
+  CounterSuperColumn counter_super_column;
252
+
253
+  _ColumnOrSuperColumn__isset __isset;
254
+
255
+  bool operator == (const ColumnOrSuperColumn & rhs) const
256
+  {
257
+    if (__isset.column != rhs.__isset.column)
258
+      return false;
259
+    else if (__isset.column && !(column == rhs.column))
260
+      return false;
261
+    if (__isset.super_column != rhs.__isset.super_column)
262
+      return false;
263
+    else if (__isset.super_column && !(super_column == rhs.super_column))
264
+      return false;
265
+    if (__isset.counter_column != rhs.__isset.counter_column)
266
+      return false;
267
+    else if (__isset.counter_column && !(counter_column == rhs.counter_column))
268
+      return false;
269
+    if (__isset.counter_super_column != rhs.__isset.counter_super_column)
270
+      return false;
271
+    else if (__isset.counter_super_column && !(counter_super_column == rhs.counter_super_column))
272
+      return false;
273
+    return true;
274
+  }
275
+  bool operator != (const ColumnOrSuperColumn &rhs) const {
276
+    return !(*this == rhs);
277
+  }
278
+
279
+  bool operator < (const ColumnOrSuperColumn & ) const;
280
+
281
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
282
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
283
+
284
+};
285
+
286
+
287
+class NotFoundException : public ::apache::thrift::TException {
288
+ public:
289
+
290
+  static const char* ascii_fingerprint; // = "99914B932BD37A50B983C5E7C90AE93B";
291
+  static const uint8_t binary_fingerprint[16]; // = {0x99,0x91,0x4B,0x93,0x2B,0xD3,0x7A,0x50,0xB9,0x83,0xC5,0xE7,0xC9,0x0A,0xE9,0x3B};
292
+
293
+  NotFoundException() {
294
+  }
295
+
296
+  virtual ~NotFoundException() throw() {}
297
+
298
+
299
+  bool operator == (const NotFoundException & /* rhs */) const
300
+  {
301
+    return true;
302
+  }
303
+  bool operator != (const NotFoundException &rhs) const {
304
+    return !(*this == rhs);
305
+  }
306
+
307
+  bool operator < (const NotFoundException & ) const;
308
+
309
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
310
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
311
+
312
+};
313
+
314
+
315
+class InvalidRequestException : public ::apache::thrift::TException {
316
+ public:
317
+
318
+  static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1";
319
+  static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
320
+
321
+  InvalidRequestException() : why("") {
322
+  }
323
+
324
+  virtual ~InvalidRequestException() throw() {}
325
+
326
+  std::string why;
327
+
328
+  bool operator == (const InvalidRequestException & rhs) const
329
+  {
330
+    if (!(why == rhs.why))
331
+      return false;
332
+    return true;
333
+  }
334
+  bool operator != (const InvalidRequestException &rhs) const {
335
+    return !(*this == rhs);
336
+  }
337
+
338
+  bool operator < (const InvalidRequestException & ) const;
339
+
340
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
341
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
342
+
343
+};
344
+
345
+
346
+class UnavailableException : public ::apache::thrift::TException {
347
+ public:
348
+
349
+  static const char* ascii_fingerprint; // = "99914B932BD37A50B983C5E7C90AE93B";
350
+  static const uint8_t binary_fingerprint[16]; // = {0x99,0x91,0x4B,0x93,0x2B,0xD3,0x7A,0x50,0xB9,0x83,0xC5,0xE7,0xC9,0x0A,0xE9,0x3B};
351
+
352
+  UnavailableException() {
353
+  }
354
+
355
+  virtual ~UnavailableException() throw() {}
356
+
357
+
358
+  bool operator == (const UnavailableException & /* rhs */) const
359
+  {
360
+    return true;
361
+  }
362
+  bool operator != (const UnavailableException &rhs) const {
363
+    return !(*this == rhs);
364
+  }
365
+
366
+  bool operator < (const UnavailableException & ) const;
367
+
368
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
369
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
370
+
371
+};
372
+
373
+
374
+class TimedOutException : public ::apache::thrift::TException {
375
+ public:
376
+
377
+  static const char* ascii_fingerprint; // = "99914B932BD37A50B983C5E7C90AE93B";
378
+  static const uint8_t binary_fingerprint[16]; // = {0x99,0x91,0x4B,0x93,0x2B,0xD3,0x7A,0x50,0xB9,0x83,0xC5,0xE7,0xC9,0x0A,0xE9,0x3B};
379
+
380
+  TimedOutException() {
381
+  }
382
+
383
+  virtual ~TimedOutException() throw() {}
384
+
385
+
386
+  bool operator == (const TimedOutException & /* rhs */) const
387
+  {
388
+    return true;
389
+  }
390
+  bool operator != (const TimedOutException &rhs) const {
391
+    return !(*this == rhs);
392
+  }
393
+
394
+  bool operator < (const TimedOutException & ) const;
395
+
396
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
397
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
398
+
399
+};
400
+
401
+
402
+class AuthenticationException : public ::apache::thrift::TException {
403
+ public:
404
+
405
+  static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1";
406
+  static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
407
+
408
+  AuthenticationException() : why("") {
409
+  }
410
+
411
+  virtual ~AuthenticationException() throw() {}
412
+
413
+  std::string why;
414
+
415
+  bool operator == (const AuthenticationException & rhs) const
416
+  {
417
+    if (!(why == rhs.why))
418
+      return false;
419
+    return true;
420
+  }
421
+  bool operator != (const AuthenticationException &rhs) const {
422
+    return !(*this == rhs);
423
+  }
424
+
425
+  bool operator < (const AuthenticationException & ) const;
426
+
427
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
428
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
429
+
430
+};
431
+
432
+
433
+class AuthorizationException : public ::apache::thrift::TException {
434
+ public:
435
+
436
+  static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1";
437
+  static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
438
+
439
+  AuthorizationException() : why("") {
440
+  }
441
+
442
+  virtual ~AuthorizationException() throw() {}
443
+
444
+  std::string why;
445
+
446
+  bool operator == (const AuthorizationException & rhs) const
447
+  {
448
+    if (!(why == rhs.why))
449
+      return false;
450
+    return true;
451
+  }
452
+  bool operator != (const AuthorizationException &rhs) const {
453
+    return !(*this == rhs);
454
+  }
455
+
456
+  bool operator < (const AuthorizationException & ) const;
457
+
458
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
459
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
460
+
461
+};
462
+
463
+
464
+class SchemaDisagreementException : 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
+  SchemaDisagreementException() {
471
+  }
472
+
473
+  virtual ~SchemaDisagreementException() throw() {}
474
+
475
+
476
+  bool operator == (const SchemaDisagreementException & /* rhs */) const
477
+  {
478
+    return true;
479
+  }
480
+  bool operator != (const SchemaDisagreementException &rhs) const {
481
+    return !(*this == rhs);
482
+  }
483
+
484
+  bool operator < (const SchemaDisagreementException & ) 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
+typedef struct _ColumnParent__isset {
492
+  _ColumnParent__isset() : super_column(false) {}
493
+  bool super_column;
494
+} _ColumnParent__isset;
495
+
496
+class ColumnParent {
497
+ public:
498
+
499
+  static const char* ascii_fingerprint; // = "0A13AE61181713A4100DFFB3EC293822";
500
+  static const uint8_t binary_fingerprint[16]; // = {0x0A,0x13,0xAE,0x61,0x18,0x17,0x13,0xA4,0x10,0x0D,0xFF,0xB3,0xEC,0x29,0x38,0x22};
501
+
502
+  ColumnParent() : column_family(""), super_column("") {
503
+  }
504
+
505
+  virtual ~ColumnParent() throw() {}
506
+
507
+  std::string column_family;
508
+  std::string super_column;
509
+
510
+  _ColumnParent__isset __isset;
511
+
512
+  bool operator == (const ColumnParent & rhs) const
513
+  {
514
+    if (!(column_family == rhs.column_family))
515
+      return false;
516
+    if (__isset.super_column != rhs.__isset.super_column)
517
+      return false;
518
+    else if (__isset.super_column && !(super_column == rhs.super_column))
519
+      return false;
520
+    return true;
521
+  }
522
+  bool operator != (const ColumnParent &rhs) const {
523
+    return !(*this == rhs);
524
+  }
525
+
526
+  bool operator < (const ColumnParent & ) const;
527
+
528
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
529
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
530
+
531
+};
532
+
533
+typedef struct _ColumnPath__isset {
534
+  _ColumnPath__isset() : super_column(false), column(false) {}
535
+  bool super_column;
536
+  bool column;
537
+} _ColumnPath__isset;
538
+
539
+class ColumnPath {
540
+ public:
541
+
542
+  static const char* ascii_fingerprint; // = "606212895BCF63C757913CF35AEB3462";
543
+  static const uint8_t binary_fingerprint[16]; // = {0x60,0x62,0x12,0x89,0x5B,0xCF,0x63,0xC7,0x57,0x91,0x3C,0xF3,0x5A,0xEB,0x34,0x62};
544
+
545
+  ColumnPath() : column_family(""), super_column(""), column("") {
546
+  }
547
+
548
+  virtual ~ColumnPath() throw() {}
549
+
550
+  std::string column_family;
551
+  std::string super_column;
552
+  std::string column;
553
+
554
+  _ColumnPath__isset __isset;
555
+
556
+  bool operator == (const ColumnPath & rhs) const
557
+  {
558
+    if (!(column_family == rhs.column_family))
559
+      return false;
560
+    if (__isset.super_column != rhs.__isset.super_column)
561
+      return false;
562
+    else if (__isset.super_column && !(super_column == rhs.super_column))
563
+      return false;
564
+    if (__isset.column != rhs.__isset.column)
565
+      return false;
566
+    else if (__isset.column && !(column == rhs.column))
567
+      return false;
568
+    return true;
569
+  }
570
+  bool operator != (const ColumnPath &rhs) const {
571
+    return !(*this == rhs);
572
+  }
573
+
574
+  bool operator < (const ColumnPath & ) const;
575
+
576
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
577
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
578
+
579
+};
580
+
581
+
582
+class SliceRange {
583
+ public:
584
+
585
+  static const char* ascii_fingerprint; // = "184D24C9A0B8D4415E234DB649CAE740";
586
+  static const uint8_t binary_fingerprint[16]; // = {0x18,0x4D,0x24,0xC9,0xA0,0xB8,0xD4,0x41,0x5E,0x23,0x4D,0xB6,0x49,0xCA,0xE7,0x40};
587
+
588
+  SliceRange() : start(""), finish(""), reversed(false), count(100) {
589
+  }
590
+
591
+  virtual ~SliceRange() throw() {}
592
+
593
+  std::string start;
594
+  std::string finish;
595
+  bool reversed;
596
+  int32_t count;
597
+
598
+  bool operator == (const SliceRange & rhs) const
599
+  {
600
+    if (!(start == rhs.start))
601
+      return false;
602
+    if (!(finish == rhs.finish))
603
+      return false;
604
+    if (!(reversed == rhs.reversed))
605
+      return false;
606
+    if (!(count == rhs.count))
607
+      return false;
608
+    return true;
609
+  }
610
+  bool operator != (const SliceRange &rhs) const {
611
+    return !(*this == rhs);
612
+  }
613
+
614
+  bool operator < (const SliceRange & ) const;
615
+
616
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
617
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
618
+
619
+};
620
+
621
+typedef struct _SlicePredicate__isset {
622
+  _SlicePredicate__isset() : column_names(false), slice_range(false) {}
623
+  bool column_names;
624
+  bool slice_range;
625
+} _SlicePredicate__isset;
626
+
627
+class SlicePredicate {
628
+ public:
629
+
630
+  static const char* ascii_fingerprint; // = "F59D1D81C17DFFAF09988BF1C9CE5E27";
631
+  static const uint8_t binary_fingerprint[16]; // = {0xF5,0x9D,0x1D,0x81,0xC1,0x7D,0xFF,0xAF,0x09,0x98,0x8B,0xF1,0xC9,0xCE,0x5E,0x27};
632
+
633
+  SlicePredicate() {
634
+  }
635
+
636
+  virtual ~SlicePredicate() throw() {}
637
+
638
+  std::vector<std::string>  column_names;
639
+  SliceRange slice_range;
640
+
641
+  _SlicePredicate__isset __isset;
642
+
643
+  bool operator == (const SlicePredicate & rhs) const
644
+  {
645
+    if (__isset.column_names != rhs.__isset.column_names)
646
+      return false;
647
+    else if (__isset.column_names && !(column_names == rhs.column_names))
648
+      return false;
649
+    if (__isset.slice_range != rhs.__isset.slice_range)
650
+      return false;
651
+    else if (__isset.slice_range && !(slice_range == rhs.slice_range))
652
+      return false;
653
+    return true;
654
+  }
655
+  bool operator != (const SlicePredicate &rhs) const {
656
+    return !(*this == rhs);
657
+  }
658
+
659
+  bool operator < (const SlicePredicate & ) const;
660
+
661
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
662
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
663
+
664
+};
665
+
666
+
667
+class IndexExpression {
668
+ public:
669
+
670
+  static const char* ascii_fingerprint; // = "D9F4CFE2F293A8B1052FD3031DD2C847";
671
+  static const uint8_t binary_fingerprint[16]; // = {0xD9,0xF4,0xCF,0xE2,0xF2,0x93,0xA8,0xB1,0x05,0x2F,0xD3,0x03,0x1D,0xD2,0xC8,0x47};
672
+
673
+  IndexExpression() : column_name(""), value("") {
674
+  }
675
+
676
+  virtual ~IndexExpression() throw() {}
677
+
678
+  std::string column_name;
679
+  IndexOperator::type op;
680
+  std::string value;
681
+
682
+  bool operator == (const IndexExpression & rhs) const
683
+  {
684
+    if (!(column_name == rhs.column_name))
685
+      return false;
686
+    if (!(op == rhs.op))
687
+      return false;
688
+    if (!(value == rhs.value))
689
+      return false;
690
+    return true;
691
+  }
692
+  bool operator != (const IndexExpression &rhs) const {
693
+    return !(*this == rhs);
694
+  }
695
+
696
+  bool operator < (const IndexExpression & ) const;
697
+
698
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
699
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
700
+
701
+};
702
+
703
+
704
+class IndexClause {
705
+ public:
706
+
707
+  static const char* ascii_fingerprint; // = "9B551B9AB86120B0EEA9005C77FD3C1F";
708
+  static const uint8_t binary_fingerprint[16]; // = {0x9B,0x55,0x1B,0x9A,0xB8,0x61,0x20,0xB0,0xEE,0xA9,0x00,0x5C,0x77,0xFD,0x3C,0x1F};
709
+
710
+  IndexClause() : start_key(""), count(100) {
711
+  }
712
+
713
+  virtual ~IndexClause() throw() {}
714
+
715
+  std::vector<IndexExpression>  expressions;
716
+  std::string start_key;
717
+  int32_t count;
718
+
719
+  bool operator == (const IndexClause & rhs) const
720
+  {
721
+    if (!(expressions == rhs.expressions))
722
+      return false;
723
+    if (!(start_key == rhs.start_key))
724
+      return false;
725
+    if (!(count == rhs.count))
726
+      return false;
727
+    return true;
728
+  }
729
+  bool operator != (const IndexClause &rhs) const {
730
+    return !(*this == rhs);
731
+  }
732
+
733
+  bool operator < (const IndexClause & ) const;
734
+
735
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
736
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
737
+
738
+};
739
+
740
+typedef struct _KeyRange__isset {
741
+  _KeyRange__isset() : start_key(false), end_key(false), start_token(false), end_token(false) {}
742
+  bool start_key;
743
+  bool end_key;
744
+  bool start_token;
745
+  bool end_token;
746
+} _KeyRange__isset;
747
+
748
+class KeyRange {
749
+ public:
750
+
751
+  static const char* ascii_fingerprint; // = "8F248C09AF1EC3656ABD8565EA1F59C1";
752
+  static const uint8_t binary_fingerprint[16]; // = {0x8F,0x24,0x8C,0x09,0xAF,0x1E,0xC3,0x65,0x6A,0xBD,0x85,0x65,0xEA,0x1F,0x59,0xC1};
753
+
754
+  KeyRange() : start_key(""), end_key(""), start_token(""), end_token(""), count(100) {
755
+  }
756
+
757
+  virtual ~KeyRange() throw() {}
758
+
759
+  std::string start_key;
760
+  std::string end_key;
761
+  std::string start_token;
762
+  std::string end_token;
763
+  int32_t count;
764
+
765
+  _KeyRange__isset __isset;
766
+
767
+  bool operator == (const KeyRange & rhs) const
768
+  {
769
+    if (__isset.start_key != rhs.__isset.start_key)
770
+      return false;
771
+    else if (__isset.start_key && !(start_key == rhs.start_key))
772
+      return false;
773
+    if (__isset.end_key != rhs.__isset.end_key)
774
+      return false;
775
+    else if (__isset.end_key && !(end_key == rhs.end_key))
776
+      return false;
777
+    if (__isset.start_token != rhs.__isset.start_token)
778
+      return false;
779
+    else if (__isset.start_token && !(start_token == rhs.start_token))
780
+      return false;
781
+    if (__isset.end_token != rhs.__isset.end_token)
782
+      return false;
783
+    else if (__isset.end_token && !(end_token == rhs.end_token))
784
+      return false;
785
+    if (!(count == rhs.count))
786
+      return false;
787
+    return true;
788
+  }
789
+  bool operator != (const KeyRange &rhs) const {
790
+    return !(*this == rhs);
791
+  }
792
+
793
+  bool operator < (const KeyRange & ) const;
794
+
795
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
796
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
797
+
798
+};
799
+
800
+
801
+class KeySlice {
802
+ public:
803
+
804
+  static const char* ascii_fingerprint; // = "D1568675B0C135C909E3169B72A4DA3D";
805
+  static const uint8_t binary_fingerprint[16]; // = {0xD1,0x56,0x86,0x75,0xB0,0xC1,0x35,0xC9,0x09,0xE3,0x16,0x9B,0x72,0xA4,0xDA,0x3D};
806
+
807
+  KeySlice() : key("") {
808
+  }
809
+
810
+  virtual ~KeySlice() throw() {}
811
+
812
+  std::string key;
813
+  std::vector<ColumnOrSuperColumn>  columns;
814
+
815
+  bool operator == (const KeySlice & rhs) const
816
+  {
817
+    if (!(key == rhs.key))
818
+      return false;
819
+    if (!(columns == rhs.columns))
820
+      return false;
821
+    return true;
822
+  }
823
+  bool operator != (const KeySlice &rhs) const {
824
+    return !(*this == rhs);
825
+  }
826
+
827
+  bool operator < (const KeySlice & ) const;
828
+
829
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
830
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
831
+
832
+};
833
+
834
+
835
+class KeyCount {
836
+ public:
837
+
838
+  static const char* ascii_fingerprint; // = "EEBC915CE44901401D881E6091423036";
839
+  static const uint8_t binary_fingerprint[16]; // = {0xEE,0xBC,0x91,0x5C,0xE4,0x49,0x01,0x40,0x1D,0x88,0x1E,0x60,0x91,0x42,0x30,0x36};
840
+
841
+  KeyCount() : key(""), count(0) {
842
+  }
843
+
844
+  virtual ~KeyCount() throw() {}
845
+
846
+  std::string key;
847
+  int32_t count;
848
+
849
+  bool operator == (const KeyCount & rhs) const
850
+  {
851
+    if (!(key == rhs.key))
852
+      return false;
853
+    if (!(count == rhs.count))
854
+      return false;
855
+    return true;
856
+  }
857
+  bool operator != (const KeyCount &rhs) const {
858
+    return !(*this == rhs);
859
+  }
860
+
861
+  bool operator < (const KeyCount & ) const;
862
+
863
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
864
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
865
+
866
+};
867
+
868
+typedef struct _Deletion__isset {
869
+  _Deletion__isset() : timestamp(false), super_column(false), predicate(false) {}
870
+  bool timestamp;
871
+  bool super_column;
872
+  bool predicate;
873
+} _Deletion__isset;
874
+
875
+class Deletion {
876
+ public:
877
+
878
+  static const char* ascii_fingerprint; // = "40F33ECF1C932CA77C2414C4E6C60CBE";
879
+  static const uint8_t binary_fingerprint[16]; // = {0x40,0xF3,0x3E,0xCF,0x1C,0x93,0x2C,0xA7,0x7C,0x24,0x14,0xC4,0xE6,0xC6,0x0C,0xBE};
880
+
881
+  Deletion() : timestamp(0), super_column("") {
882
+  }
883
+
884
+  virtual ~Deletion() throw() {}
885
+
886
+  int64_t timestamp;
887
+  std::string super_column;
888
+  SlicePredicate predicate;
889
+
890
+  _Deletion__isset __isset;
891
+
892
+  bool operator == (const Deletion & rhs) const
893
+  {
894
+    if (__isset.timestamp != rhs.__isset.timestamp)
895
+      return false;
896
+    else if (__isset.timestamp && !(timestamp == rhs.timestamp))
897
+      return false;
898
+    if (__isset.super_column != rhs.__isset.super_column)
899
+      return false;
900
+    else if (__isset.super_column && !(super_column == rhs.super_column))
901
+      return false;
902
+    if (__isset.predicate != rhs.__isset.predicate)
903
+      return false;
904
+    else if (__isset.predicate && !(predicate == rhs.predicate))