1 /**
2  * Autogenerated by Thrift Compiler (0.9.0)
3  *
4  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5  *  @generated
6  */
7 #ifndef Hbase_H
8 #define Hbase_H
9 
10 #include <thrift/TDispatchProcessor.h>
11 #include "Hbase_types.h"
12 
13 namespace apache { namespace hadoop { namespace hbase { namespace thrift {
14 
15 class HbaseIf {
16  public:
~HbaseIf()17   virtual ~HbaseIf() {}
18   virtual void enableTable(const Bytes& tableName) = 0;
19   virtual void disableTable(const Bytes& tableName) = 0;
20   virtual bool isTableEnabled(const Bytes& tableName) = 0;
21   virtual void compact(const Bytes& tableNameOrRegionName) = 0;
22   virtual void majorCompact(const Bytes& tableNameOrRegionName) = 0;
23   virtual void getTableNames(std::vector<Text> & _return) = 0;
24   virtual void getColumnDescriptors(std::map<Text, ColumnDescriptor> & _return, const Text& tableName) = 0;
25   virtual void getTableRegions(std::vector<TRegionInfo> & _return, const Text& tableName) = 0;
26   virtual void createTable(const Text& tableName, const std::vector<ColumnDescriptor> & columnFamilies) = 0;
27   virtual void deleteTable(const Text& tableName) = 0;
28   virtual void get(std::vector<TCell> & _return, const Text& tableName, const Text& row, const Text& column, const std::map<Text, Text> & attributes) = 0;
29   virtual void getVer(std::vector<TCell> & _return, const Text& tableName, const Text& row, const Text& column, const int32_t numVersions, const std::map<Text, Text> & attributes) = 0;
30   virtual void getVerTs(std::vector<TCell> & _return, const Text& tableName, const Text& row, const Text& column, const int64_t timestamp, const int32_t numVersions, const std::map<Text, Text> & attributes) = 0;
31   virtual void getRow(std::vector<TRowResult> & _return, const Text& tableName, const Text& row, const std::map<Text, Text> & attributes) = 0;
32   virtual void getRowWithColumns(std::vector<TRowResult> & _return, const Text& tableName, const Text& row, const std::vector<Text> & columns, const std::map<Text, Text> & attributes) = 0;
33   virtual void getRowTs(std::vector<TRowResult> & _return, const Text& tableName, const Text& row, const int64_t timestamp, const std::map<Text, Text> & attributes) = 0;
34   virtual void getRowWithColumnsTs(std::vector<TRowResult> & _return, const Text& tableName, const Text& row, const std::vector<Text> & columns, const int64_t timestamp, const std::map<Text, Text> & attributes) = 0;
35   virtual void getRows(std::vector<TRowResult> & _return, const Text& tableName, const std::vector<Text> & rows, const std::map<Text, Text> & attributes) = 0;
36   virtual void getRowsWithColumns(std::vector<TRowResult> & _return, const Text& tableName, const std::vector<Text> & rows, const std::vector<Text> & columns, const std::map<Text, Text> & attributes) = 0;
37   virtual void getRowsTs(std::vector<TRowResult> & _return, const Text& tableName, const std::vector<Text> & rows, const int64_t timestamp, const std::map<Text, Text> & attributes) = 0;
38   virtual void getRowsWithColumnsTs(std::vector<TRowResult> & _return, const Text& tableName, const std::vector<Text> & rows, const std::vector<Text> & columns, const int64_t timestamp, const std::map<Text, Text> & attributes) = 0;
39   virtual void mutateRow(const Text& tableName, const Text& row, const std::vector<Mutation> & mutations, const std::map<Text, Text> & attributes) = 0;
40   virtual void mutateRowTs(const Text& tableName, const Text& row, const std::vector<Mutation> & mutations, const int64_t timestamp, const std::map<Text, Text> & attributes) = 0;
41   virtual void mutateRows(const Text& tableName, const std::vector<BatchMutation> & rowBatches, const std::map<Text, Text> & attributes) = 0;
42   virtual void mutateRowsTs(const Text& tableName, const std::vector<BatchMutation> & rowBatches, const int64_t timestamp, const std::map<Text, Text> & attributes) = 0;
43   virtual int64_t atomicIncrement(const Text& tableName, const Text& row, const Text& column, const int64_t value) = 0;
44   virtual void deleteAll(const Text& tableName, const Text& row, const Text& column, const std::map<Text, Text> & attributes) = 0;
45   virtual void deleteAllTs(const Text& tableName, const Text& row, const Text& column, const int64_t timestamp, const std::map<Text, Text> & attributes) = 0;
46   virtual void deleteAllRow(const Text& tableName, const Text& row, const std::map<Text, Text> & attributes) = 0;
47   virtual void increment(const TIncrement& increment) = 0;
48   virtual void incrementRows(const std::vector<TIncrement> & increments) = 0;
49   virtual void deleteAllRowTs(const Text& tableName, const Text& row, const int64_t timestamp, const std::map<Text, Text> & attributes) = 0;
50   virtual ScannerID scannerOpenWithScan(const Text& tableName, const TScan& scan, const std::map<Text, Text> & attributes) = 0;
51   virtual ScannerID scannerOpen(const Text& tableName, const Text& startRow, const std::vector<Text> & columns, const std::map<Text, Text> & attributes) = 0;
52   virtual ScannerID scannerOpenWithStop(const Text& tableName, const Text& startRow, const Text& stopRow, const std::vector<Text> & columns, const std::map<Text, Text> & attributes) = 0;
53   virtual ScannerID scannerOpenWithPrefix(const Text& tableName, const Text& startAndPrefix, const std::vector<Text> & columns, const std::map<Text, Text> & attributes) = 0;
54   virtual ScannerID scannerOpenTs(const Text& tableName, const Text& startRow, const std::vector<Text> & columns, const int64_t timestamp, const std::map<Text, Text> & attributes) = 0;
55   virtual ScannerID scannerOpenWithStopTs(const Text& tableName, const Text& startRow, const Text& stopRow, const std::vector<Text> & columns, const int64_t timestamp, const std::map<Text, Text> & attributes) = 0;
56   virtual void scannerGet(std::vector<TRowResult> & _return, const ScannerID id) = 0;
57   virtual void scannerGetList(std::vector<TRowResult> & _return, const ScannerID id, const int32_t nbRows) = 0;
58   virtual void scannerClose(const ScannerID id) = 0;
59   virtual void getRowOrBefore(std::vector<TCell> & _return, const Text& tableName, const Text& row, const Text& family) = 0;
60   virtual void getRegionInfo(TRegionInfo& _return, const Text& row) = 0;
61 };
62 
63 class HbaseIfFactory {
64  public:
65   typedef HbaseIf Handler;
66 
~HbaseIfFactory()67   virtual ~HbaseIfFactory() {}
68 
69   virtual HbaseIf* getHandler(const ::apache::thrift::TConnectionInfo& connInfo) = 0;
70   virtual void releaseHandler(HbaseIf* /* handler */) = 0;
71 };
72 
73 class HbaseIfSingletonFactory : virtual public HbaseIfFactory {
74  public:
HbaseIfSingletonFactory(const boost::shared_ptr<HbaseIf> & iface)75   HbaseIfSingletonFactory(const boost::shared_ptr<HbaseIf>& iface) : iface_(iface) {}
~HbaseIfSingletonFactory()76   virtual ~HbaseIfSingletonFactory() {}
77 
getHandler(const::apache::thrift::TConnectionInfo &)78   virtual HbaseIf* getHandler(const ::apache::thrift::TConnectionInfo&) {
79     return iface_.get();
80   }
releaseHandler(HbaseIf *)81   virtual void releaseHandler(HbaseIf* /* handler */) {}
82 
83  protected:
84   boost::shared_ptr<HbaseIf> iface_;
85 };
86 
87 class HbaseNull : virtual public HbaseIf {
88  public:
~HbaseNull()89   virtual ~HbaseNull() {}
enableTable(const Bytes &)90   void enableTable(const Bytes& /* tableName */) {
91     return;
92   }
disableTable(const Bytes &)93   void disableTable(const Bytes& /* tableName */) {
94     return;
95   }
isTableEnabled(const Bytes &)96   bool isTableEnabled(const Bytes& /* tableName */) {
97     bool _return = false;
98     return _return;
99   }
compact(const Bytes &)100   void compact(const Bytes& /* tableNameOrRegionName */) {
101     return;
102   }
majorCompact(const Bytes &)103   void majorCompact(const Bytes& /* tableNameOrRegionName */) {
104     return;
105   }
getTableNames(std::vector<Text> &)106   void getTableNames(std::vector<Text> & /* _return */) {
107     return;
108   }
getColumnDescriptors(std::map<Text,ColumnDescriptor> &,const Text &)109   void getColumnDescriptors(std::map<Text, ColumnDescriptor> & /* _return */, const Text& /* tableName */) {
110     return;
111   }
getTableRegions(std::vector<TRegionInfo> &,const Text &)112   void getTableRegions(std::vector<TRegionInfo> & /* _return */, const Text& /* tableName */) {
113     return;
114   }
createTable(const Text &,const std::vector<ColumnDescriptor> &)115   void createTable(const Text& /* tableName */, const std::vector<ColumnDescriptor> & /* columnFamilies */) {
116     return;
117   }
deleteTable(const Text &)118   void deleteTable(const Text& /* tableName */) {
119     return;
120   }
get(std::vector<TCell> &,const Text &,const Text &,const Text &,const std::map<Text,Text> &)121   void get(std::vector<TCell> & /* _return */, const Text& /* tableName */, const Text& /* row */, const Text& /* column */, const std::map<Text, Text> & /* attributes */) {
122     return;
123   }
getVer(std::vector<TCell> &,const Text &,const Text &,const Text &,const int32_t,const std::map<Text,Text> &)124   void getVer(std::vector<TCell> & /* _return */, const Text& /* tableName */, const Text& /* row */, const Text& /* column */, const int32_t /* numVersions */, const std::map<Text, Text> & /* attributes */) {
125     return;
126   }
getVerTs(std::vector<TCell> &,const Text &,const Text &,const Text &,const int64_t,const int32_t,const std::map<Text,Text> &)127   void getVerTs(std::vector<TCell> & /* _return */, const Text& /* tableName */, const Text& /* row */, const Text& /* column */, const int64_t /* timestamp */, const int32_t /* numVersions */, const std::map<Text, Text> & /* attributes */) {
128     return;
129   }
getRow(std::vector<TRowResult> &,const Text &,const Text &,const std::map<Text,Text> &)130   void getRow(std::vector<TRowResult> & /* _return */, const Text& /* tableName */, const Text& /* row */, const std::map<Text, Text> & /* attributes */) {
131     return;
132   }
getRowWithColumns(std::vector<TRowResult> &,const Text &,const Text &,const std::vector<Text> &,const std::map<Text,Text> &)133   void getRowWithColumns(std::vector<TRowResult> & /* _return */, const Text& /* tableName */, const Text& /* row */, const std::vector<Text> & /* columns */, const std::map<Text, Text> & /* attributes */) {
134     return;
135   }
getRowTs(std::vector<TRowResult> &,const Text &,const Text &,const int64_t,const std::map<Text,Text> &)136   void getRowTs(std::vector<TRowResult> & /* _return */, const Text& /* tableName */, const Text& /* row */, const int64_t /* timestamp */, const std::map<Text, Text> & /* attributes */) {
137     return;
138   }
getRowWithColumnsTs(std::vector<TRowResult> &,const Text &,const Text &,const std::vector<Text> &,const int64_t,const std::map<Text,Text> &)139   void getRowWithColumnsTs(std::vector<TRowResult> & /* _return */, const Text& /* tableName */, const Text& /* row */, const std::vector<Text> & /* columns */, const int64_t /* timestamp */, const std::map<Text, Text> & /* attributes */) {
140     return;
141   }
getRows(std::vector<TRowResult> &,const Text &,const std::vector<Text> &,const std::map<Text,Text> &)142   void getRows(std::vector<TRowResult> & /* _return */, const Text& /* tableName */, const std::vector<Text> & /* rows */, const std::map<Text, Text> & /* attributes */) {
143     return;
144   }
getRowsWithColumns(std::vector<TRowResult> &,const Text &,const std::vector<Text> &,const std::vector<Text> &,const std::map<Text,Text> &)145   void getRowsWithColumns(std::vector<TRowResult> & /* _return */, const Text& /* tableName */, const std::vector<Text> & /* rows */, const std::vector<Text> & /* columns */, const std::map<Text, Text> & /* attributes */) {
146     return;
147   }
getRowsTs(std::vector<TRowResult> &,const Text &,const std::vector<Text> &,const int64_t,const std::map<Text,Text> &)148   void getRowsTs(std::vector<TRowResult> & /* _return */, const Text& /* tableName */, const std::vector<Text> & /* rows */, const int64_t /* timestamp */, const std::map<Text, Text> & /* attributes */) {
149     return;
150   }
getRowsWithColumnsTs(std::vector<TRowResult> &,const Text &,const std::vector<Text> &,const std::vector<Text> &,const int64_t,const std::map<Text,Text> &)151   void getRowsWithColumnsTs(std::vector<TRowResult> & /* _return */, const Text& /* tableName */, const std::vector<Text> & /* rows */, const std::vector<Text> & /* columns */, const int64_t /* timestamp */, const std::map<Text, Text> & /* attributes */) {
152     return;
153   }
mutateRow(const Text &,const Text &,const std::vector<Mutation> &,const std::map<Text,Text> &)154   void mutateRow(const Text& /* tableName */, const Text& /* row */, const std::vector<Mutation> & /* mutations */, const std::map<Text, Text> & /* attributes */) {
155     return;
156   }
mutateRowTs(const Text &,const Text &,const std::vector<Mutation> &,const int64_t,const std::map<Text,Text> &)157   void mutateRowTs(const Text& /* tableName */, const Text& /* row */, const std::vector<Mutation> & /* mutations */, const int64_t /* timestamp */, const std::map<Text, Text> & /* attributes */) {
158     return;
159   }
mutateRows(const Text &,const std::vector<BatchMutation> &,const std::map<Text,Text> &)160   void mutateRows(const Text& /* tableName */, const std::vector<BatchMutation> & /* rowBatches */, const std::map<Text, Text> & /* attributes */) {
161     return;
162   }
mutateRowsTs(const Text &,const std::vector<BatchMutation> &,const int64_t,const std::map<Text,Text> &)163   void mutateRowsTs(const Text& /* tableName */, const std::vector<BatchMutation> & /* rowBatches */, const int64_t /* timestamp */, const std::map<Text, Text> & /* attributes */) {
164     return;
165   }
atomicIncrement(const Text &,const Text &,const Text &,const int64_t)166   int64_t atomicIncrement(const Text& /* tableName */, const Text& /* row */, const Text& /* column */, const int64_t /* value */) {
167     int64_t _return = 0;
168     return _return;
169   }
deleteAll(const Text &,const Text &,const Text &,const std::map<Text,Text> &)170   void deleteAll(const Text& /* tableName */, const Text& /* row */, const Text& /* column */, const std::map<Text, Text> & /* attributes */) {
171     return;
172   }
deleteAllTs(const Text &,const Text &,const Text &,const int64_t,const std::map<Text,Text> &)173   void deleteAllTs(const Text& /* tableName */, const Text& /* row */, const Text& /* column */, const int64_t /* timestamp */, const std::map<Text, Text> & /* attributes */) {
174     return;
175   }
deleteAllRow(const Text &,const Text &,const std::map<Text,Text> &)176   void deleteAllRow(const Text& /* tableName */, const Text& /* row */, const std::map<Text, Text> & /* attributes */) {
177     return;
178   }
increment(const TIncrement &)179   void increment(const TIncrement& /* increment */) {
180     return;
181   }
incrementRows(const std::vector<TIncrement> &)182   void incrementRows(const std::vector<TIncrement> & /* increments */) {
183     return;
184   }
deleteAllRowTs(const Text &,const Text &,const int64_t,const std::map<Text,Text> &)185   void deleteAllRowTs(const Text& /* tableName */, const Text& /* row */, const int64_t /* timestamp */, const std::map<Text, Text> & /* attributes */) {
186     return;
187   }
scannerOpenWithScan(const Text &,const TScan &,const std::map<Text,Text> &)188   ScannerID scannerOpenWithScan(const Text& /* tableName */, const TScan& /* scan */, const std::map<Text, Text> & /* attributes */) {
189     ScannerID _return = 0;
190     return _return;
191   }
scannerOpen(const Text &,const Text &,const std::vector<Text> &,const std::map<Text,Text> &)192   ScannerID scannerOpen(const Text& /* tableName */, const Text& /* startRow */, const std::vector<Text> & /* columns */, const std::map<Text, Text> & /* attributes */) {
193     ScannerID _return = 0;
194     return _return;
195   }
scannerOpenWithStop(const Text &,const Text &,const Text &,const std::vector<Text> &,const std::map<Text,Text> &)196   ScannerID scannerOpenWithStop(const Text& /* tableName */, const Text& /* startRow */, const Text& /* stopRow */, const std::vector<Text> & /* columns */, const std::map<Text, Text> & /* attributes */) {
197     ScannerID _return = 0;
198     return _return;
199   }
scannerOpenWithPrefix(const Text &,const Text &,const std::vector<Text> &,const std::map<Text,Text> &)200   ScannerID scannerOpenWithPrefix(const Text& /* tableName */, const Text& /* startAndPrefix */, const std::vector<Text> & /* columns */, const std::map<Text, Text> & /* attributes */) {
201     ScannerID _return = 0;
202     return _return;
203   }
scannerOpenTs(const Text &,const Text &,const std::vector<Text> &,const int64_t,const std::map<Text,Text> &)204   ScannerID scannerOpenTs(const Text& /* tableName */, const Text& /* startRow */, const std::vector<Text> & /* columns */, const int64_t /* timestamp */, const std::map<Text, Text> & /* attributes */) {
205     ScannerID _return = 0;
206     return _return;
207   }
scannerOpenWithStopTs(const Text &,const Text &,const Text &,const std::vector<Text> &,const int64_t,const std::map<Text,Text> &)208   ScannerID scannerOpenWithStopTs(const Text& /* tableName */, const Text& /* startRow */, const Text& /* stopRow */, const std::vector<Text> & /* columns */, const int64_t /* timestamp */, const std::map<Text, Text> & /* attributes */) {
209     ScannerID _return = 0;
210     return _return;
211   }
scannerGet(std::vector<TRowResult> &,const ScannerID)212   void scannerGet(std::vector<TRowResult> & /* _return */, const ScannerID /* id */) {
213     return;
214   }
scannerGetList(std::vector<TRowResult> &,const ScannerID,const int32_t)215   void scannerGetList(std::vector<TRowResult> & /* _return */, const ScannerID /* id */, const int32_t /* nbRows */) {
216     return;
217   }
scannerClose(const ScannerID)218   void scannerClose(const ScannerID /* id */) {
219     return;
220   }
getRowOrBefore(std::vector<TCell> &,const Text &,const Text &,const Text &)221   void getRowOrBefore(std::vector<TCell> & /* _return */, const Text& /* tableName */, const Text& /* row */, const Text& /* family */) {
222     return;
223   }
getRegionInfo(TRegionInfo &,const Text &)224   void getRegionInfo(TRegionInfo& /* _return */, const Text& /* row */) {
225     return;
226   }
227 };
228 
229 typedef struct _Hbase_enableTable_args__isset {
_Hbase_enableTable_args__isset_Hbase_enableTable_args__isset230   _Hbase_enableTable_args__isset() : tableName(false) {}
231   bool tableName;
232 } _Hbase_enableTable_args__isset;
233 
234 class Hbase_enableTable_args {
235  public:
236 
Hbase_enableTable_args()237   Hbase_enableTable_args() : tableName() {
238   }
239 
~Hbase_enableTable_args()240   virtual ~Hbase_enableTable_args() throw() {}
241 
242   Bytes tableName;
243 
244   _Hbase_enableTable_args__isset __isset;
245 
__set_tableName(const Bytes & val)246   void __set_tableName(const Bytes& val) {
247     tableName = val;
248   }
249 
250   bool operator == (const Hbase_enableTable_args & rhs) const
251   {
252     if (!(tableName == rhs.tableName))
253       return false;
254     return true;
255   }
256   bool operator != (const Hbase_enableTable_args &rhs) const {
257     return !(*this == rhs);
258   }
259 
260   bool operator < (const Hbase_enableTable_args & ) const;
261 
262   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
263   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
264 
265 };
266 
267 
268 class Hbase_enableTable_pargs {
269  public:
270 
271 
~Hbase_enableTable_pargs()272   virtual ~Hbase_enableTable_pargs() throw() {}
273 
274   const Bytes* tableName;
275 
276   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
277 
278 };
279 
280 typedef struct _Hbase_enableTable_result__isset {
_Hbase_enableTable_result__isset_Hbase_enableTable_result__isset281   _Hbase_enableTable_result__isset() : io(false) {}
282   bool io;
283 } _Hbase_enableTable_result__isset;
284 
285 class Hbase_enableTable_result {
286  public:
287 
Hbase_enableTable_result()288   Hbase_enableTable_result() {
289   }
290 
~Hbase_enableTable_result()291   virtual ~Hbase_enableTable_result() throw() {}
292 
293   IOError io;
294 
295   _Hbase_enableTable_result__isset __isset;
296 
__set_io(const IOError & val)297   void __set_io(const IOError& val) {
298     io = val;
299   }
300 
301   bool operator == (const Hbase_enableTable_result & rhs) const
302   {
303     if (!(io == rhs.io))
304       return false;
305     return true;
306   }
307   bool operator != (const Hbase_enableTable_result &rhs) const {
308     return !(*this == rhs);
309   }
310 
311   bool operator < (const Hbase_enableTable_result & ) const;
312 
313   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
314   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
315 
316 };
317 
318 typedef struct _Hbase_enableTable_presult__isset {
_Hbase_enableTable_presult__isset_Hbase_enableTable_presult__isset319   _Hbase_enableTable_presult__isset() : io(false) {}
320   bool io;
321 } _Hbase_enableTable_presult__isset;
322 
323 class Hbase_enableTable_presult {
324  public:
325 
326 
~Hbase_enableTable_presult()327   virtual ~Hbase_enableTable_presult() throw() {}
328 
329   IOError io;
330 
331   _Hbase_enableTable_presult__isset __isset;
332 
333   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
334 
335 };
336 
337 typedef struct _Hbase_disableTable_args__isset {
_Hbase_disableTable_args__isset_Hbase_disableTable_args__isset338   _Hbase_disableTable_args__isset() : tableName(false) {}
339   bool tableName;
340 } _Hbase_disableTable_args__isset;
341 
342 class Hbase_disableTable_args {
343  public:
344 
Hbase_disableTable_args()345   Hbase_disableTable_args() : tableName() {
346   }
347 
~Hbase_disableTable_args()348   virtual ~Hbase_disableTable_args() throw() {}
349 
350   Bytes tableName;
351 
352   _Hbase_disableTable_args__isset __isset;
353 
__set_tableName(const Bytes & val)354   void __set_tableName(const Bytes& val) {
355     tableName = val;
356   }
357 
358   bool operator == (const Hbase_disableTable_args & rhs) const
359   {
360     if (!(tableName == rhs.tableName))
361       return false;
362     return true;
363   }
364   bool operator != (const Hbase_disableTable_args &rhs) const {
365     return !(*this == rhs);
366   }
367 
368   bool operator < (const Hbase_disableTable_args & ) const;
369 
370   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
371   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
372 
373 };
374 
375 
376 class Hbase_disableTable_pargs {
377  public:
378 
379 
~Hbase_disableTable_pargs()380   virtual ~Hbase_disableTable_pargs() throw() {}
381 
382   const Bytes* tableName;
383 
384   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
385 
386 };
387 
388 typedef struct _Hbase_disableTable_result__isset {
_Hbase_disableTable_result__isset_Hbase_disableTable_result__isset389   _Hbase_disableTable_result__isset() : io(false) {}
390   bool io;
391 } _Hbase_disableTable_result__isset;
392 
393 class Hbase_disableTable_result {
394  public:
395 
Hbase_disableTable_result()396   Hbase_disableTable_result() {
397   }
398 
~Hbase_disableTable_result()399   virtual ~Hbase_disableTable_result() throw() {}
400 
401   IOError io;
402 
403   _Hbase_disableTable_result__isset __isset;
404 
__set_io(const IOError & val)405   void __set_io(const IOError& val) {
406     io = val;
407   }
408 
409   bool operator == (const Hbase_disableTable_result & rhs) const
410   {
411     if (!(io == rhs.io))
412       return false;
413     return true;
414   }
415   bool operator != (const Hbase_disableTable_result &rhs) const {
416     return !(*this == rhs);
417   }
418 
419   bool operator < (const Hbase_disableTable_result & ) const;
420 
421   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
422   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
423 
424 };
425 
426 typedef struct _Hbase_disableTable_presult__isset {
_Hbase_disableTable_presult__isset_Hbase_disableTable_presult__isset427   _Hbase_disableTable_presult__isset() : io(false) {}
428   bool io;
429 } _Hbase_disableTable_presult__isset;
430 
431 class Hbase_disableTable_presult {
432  public:
433 
434 
~Hbase_disableTable_presult()435   virtual ~Hbase_disableTable_presult() throw() {}
436 
437   IOError io;
438 
439   _Hbase_disableTable_presult__isset __isset;
440 
441   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
442 
443 };
444 
445 typedef struct _Hbase_isTableEnabled_args__isset {
_Hbase_isTableEnabled_args__isset_Hbase_isTableEnabled_args__isset446   _Hbase_isTableEnabled_args__isset() : tableName(false) {}
447   bool tableName;
448 } _Hbase_isTableEnabled_args__isset;
449 
450 class Hbase_isTableEnabled_args {
451  public:
452 
Hbase_isTableEnabled_args()453   Hbase_isTableEnabled_args() : tableName() {
454   }
455 
~Hbase_isTableEnabled_args()456   virtual ~Hbase_isTableEnabled_args() throw() {}
457 
458   Bytes tableName;
459 
460   _Hbase_isTableEnabled_args__isset __isset;
461 
__set_tableName(const Bytes & val)462   void __set_tableName(const Bytes& val) {
463     tableName = val;
464   }
465 
466   bool operator == (const Hbase_isTableEnabled_args & rhs) const
467   {
468     if (!(tableName == rhs.tableName))
469       return false;
470     return true;
471   }
472   bool operator != (const Hbase_isTableEnabled_args &rhs) const {
473     return !(*this == rhs);
474   }
475 
476   bool operator < (const Hbase_isTableEnabled_args & ) const;
477 
478   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
479   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
480 
481 };
482 
483 
484 class Hbase_isTableEnabled_pargs {
485  public:
486 
487 
~Hbase_isTableEnabled_pargs()488   virtual ~Hbase_isTableEnabled_pargs() throw() {}
489 
490   const Bytes* tableName;
491 
492   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
493 
494 };
495 
496 typedef struct _Hbase_isTableEnabled_result__isset {
_Hbase_isTableEnabled_result__isset_Hbase_isTableEnabled_result__isset497   _Hbase_isTableEnabled_result__isset() : success(false), io(false) {}
498   bool success;
499   bool io;
500 } _Hbase_isTableEnabled_result__isset;
501 
502 class Hbase_isTableEnabled_result {
503  public:
504 
Hbase_isTableEnabled_result()505   Hbase_isTableEnabled_result() : success(0) {
506   }
507 
~Hbase_isTableEnabled_result()508   virtual ~Hbase_isTableEnabled_result() throw() {}
509 
510   bool success;
511   IOError io;
512 
513   _Hbase_isTableEnabled_result__isset __isset;
514 
__set_success(const bool val)515   void __set_success(const bool val) {
516     success = val;
517   }
518 
__set_io(const IOError & val)519   void __set_io(const IOError& val) {
520     io = val;
521   }
522 
523   bool operator == (const Hbase_isTableEnabled_result & rhs) const
524   {
525     if (!(success == rhs.success))
526       return false;
527     if (!(io == rhs.io))
528       return false;
529     return true;
530   }
531   bool operator != (const Hbase_isTableEnabled_result &rhs) const {
532     return !(*this == rhs);
533   }
534 
535   bool operator < (const Hbase_isTableEnabled_result & ) const;
536 
537   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
538   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
539 
540 };
541 
542 typedef struct _Hbase_isTableEnabled_presult__isset {
_Hbase_isTableEnabled_presult__isset_Hbase_isTableEnabled_presult__isset543   _Hbase_isTableEnabled_presult__isset() : success(false), io(false) {}
544   bool success;
545   bool io;
546 } _Hbase_isTableEnabled_presult__isset;
547 
548 class Hbase_isTableEnabled_presult {
549  public:
550 
551 
~Hbase_isTableEnabled_presult()552   virtual ~Hbase_isTableEnabled_presult() throw() {}
553 
554   bool* success;
555   IOError io;
556 
557   _Hbase_isTableEnabled_presult__isset __isset;
558 
559   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
560 
561 };
562 
563 typedef struct _Hbase_compact_args__isset {
_Hbase_compact_args__isset_Hbase_compact_args__isset564   _Hbase_compact_args__isset() : tableNameOrRegionName(false) {}
565   bool tableNameOrRegionName;
566 } _Hbase_compact_args__isset;
567 
568 class Hbase_compact_args {
569  public:
570 
Hbase_compact_args()571   Hbase_compact_args() : tableNameOrRegionName() {
572   }
573 
~Hbase_compact_args()574   virtual ~Hbase_compact_args() throw() {}
575 
576   Bytes tableNameOrRegionName;
577 
578   _Hbase_compact_args__isset __isset;
579 
__set_tableNameOrRegionName(const Bytes & val)580   void __set_tableNameOrRegionName(const Bytes& val) {
581     tableNameOrRegionName = val;
582   }
583 
584   bool operator == (const Hbase_compact_args & rhs) const
585   {
586     if (!(tableNameOrRegionName == rhs.tableNameOrRegionName))
587       return false;
588     return true;
589   }
590   bool operator != (const Hbase_compact_args &rhs) const {
591     return !(*this == rhs);
592   }
593 
594   bool operator < (const Hbase_compact_args & ) const;
595 
596   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
597   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
598 
599 };
600 
601 
602 class Hbase_compact_pargs {
603  public:
604 
605 
~Hbase_compact_pargs()606   virtual ~Hbase_compact_pargs() throw() {}
607 
608   const Bytes* tableNameOrRegionName;
609 
610   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
611 
612 };
613 
614 typedef struct _Hbase_compact_result__isset {
_Hbase_compact_result__isset_Hbase_compact_result__isset615   _Hbase_compact_result__isset() : io(false) {}
616   bool io;
617 } _Hbase_compact_result__isset;
618 
619 class Hbase_compact_result {
620  public:
621 
Hbase_compact_result()622   Hbase_compact_result() {
623   }
624 
~Hbase_compact_result()625   virtual ~Hbase_compact_result() throw() {}
626 
627   IOError io;
628 
629   _Hbase_compact_result__isset __isset;
630 
__set_io(const IOError & val)631   void __set_io(const IOError& val) {
632     io = val;
633   }
634 
635   bool operator == (const Hbase_compact_result & rhs) const
636   {
637     if (!(io == rhs.io))
638       return false;
639     return true;
640   }
641   bool operator != (const Hbase_compact_result &rhs) const {
642     return !(*this == rhs);
643   }
644 
645   bool operator < (const Hbase_compact_result & ) const;
646 
647   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
648   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
649 
650 };
651 
652 typedef struct _Hbase_compact_presult__isset {
_Hbase_compact_presult__isset_Hbase_compact_presult__isset653   _Hbase_compact_presult__isset() : io(false) {}
654   bool io;
655 } _Hbase_compact_presult__isset;
656 
657 class Hbase_compact_presult {
658  public:
659 
660 
~Hbase_compact_presult()661   virtual ~Hbase_compact_presult() throw() {}
662 
663   IOError io;
664 
665   _Hbase_compact_presult__isset __isset;
666 
667   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
668 
669 };
670 
671 typedef struct _Hbase_majorCompact_args__isset {
_Hbase_majorCompact_args__isset_Hbase_majorCompact_args__isset672   _Hbase_majorCompact_args__isset() : tableNameOrRegionName(false) {}
673   bool tableNameOrRegionName;
674 } _Hbase_majorCompact_args__isset;
675 
676 class Hbase_majorCompact_args {
677  public:
678 
Hbase_majorCompact_args()679   Hbase_majorCompact_args() : tableNameOrRegionName() {
680   }
681 
~Hbase_majorCompact_args()682   virtual ~Hbase_majorCompact_args() throw() {}
683 
684   Bytes tableNameOrRegionName;
685 
686   _Hbase_majorCompact_args__isset __isset;
687 
__set_tableNameOrRegionName(const Bytes & val)688   void __set_tableNameOrRegionName(const Bytes& val) {
689     tableNameOrRegionName = val;
690   }
691 
692   bool operator == (const Hbase_majorCompact_args & rhs) const
693   {
694     if (!(tableNameOrRegionName == rhs.tableNameOrRegionName))
695       return false;
696     return true;
697   }
698   bool operator != (const Hbase_majorCompact_args &rhs) const {
699     return !(*this == rhs);
700   }
701 
702   bool operator < (const Hbase_majorCompact_args & ) const;
703 
704   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
705   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
706 
707 };
708 
709 
710 class Hbase_majorCompact_pargs {
711  public:
712 
713 
~Hbase_majorCompact_pargs()714   virtual ~Hbase_majorCompact_pargs() throw() {}
715 
716   const Bytes* tableNameOrRegionName;
717 
718   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
719 
720 };
721 
722 typedef struct _Hbase_majorCompact_result__isset {
_Hbase_majorCompact_result__isset_Hbase_majorCompact_result__isset723   _Hbase_majorCompact_result__isset() : io(false) {}
724   bool io;
725 } _Hbase_majorCompact_result__isset;
726 
727 class Hbase_majorCompact_result {
728  public:
729 
Hbase_majorCompact_result()730   Hbase_majorCompact_result() {
731   }
732 
~Hbase_majorCompact_result()733   virtual ~Hbase_majorCompact_result() throw() {}
734 
735   IOError io;
736 
737   _Hbase_majorCompact_result__isset __isset;
738 
__set_io(const IOError & val)739   void __set_io(const IOError& val) {
740     io = val;
741   }
742 
743   bool operator == (const Hbase_majorCompact_result & rhs) const
744   {
745     if (!(io == rhs.io))
746       return false;
747     return true;
748   }
749   bool operator != (const Hbase_majorCompact_result &rhs) const {
750     return !(*this == rhs);
751   }
752 
753   bool operator < (const Hbase_majorCompact_result & ) const;
754 
755   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
756   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
757 
758 };
759 
760 typedef struct _Hbase_majorCompact_presult__isset {
_Hbase_majorCompact_presult__isset_Hbase_majorCompact_presult__isset761   _Hbase_majorCompact_presult__isset() : io(false) {}
762   bool io;
763 } _Hbase_majorCompact_presult__isset;
764 
765 class Hbase_majorCompact_presult {
766  public:
767 
768 
~Hbase_majorCompact_presult()769   virtual ~Hbase_majorCompact_presult() throw() {}
770 
771   IOError io;
772 
773   _Hbase_majorCompact_presult__isset __isset;
774 
775   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
776 
777 };
778 
779 
780 class Hbase_getTableNames_args {
781  public:
782 
Hbase_getTableNames_args()783   Hbase_getTableNames_args() {
784   }
785 
~Hbase_getTableNames_args()786   virtual ~Hbase_getTableNames_args() throw() {}
787 
788 
789   bool operator == (const Hbase_getTableNames_args & /* rhs */) const
790   {
791     return true;
792   }
793   bool operator != (const Hbase_getTableNames_args &rhs) const {
794     return !(*this == rhs);
795   }
796 
797   bool operator < (const Hbase_getTableNames_args & ) const;
798 
799   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
800   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
801 
802 };
803 
804 
805 class Hbase_getTableNames_pargs {
806  public:
807 
808 
~Hbase_getTableNames_pargs()809   virtual ~Hbase_getTableNames_pargs() throw() {}
810 
811 
812   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
813 
814 };
815 
816 typedef struct _Hbase_getTableNames_result__isset {
_Hbase_getTableNames_result__isset_Hbase_getTableNames_result__isset817   _Hbase_getTableNames_result__isset() : success(false), io(false) {}
818   bool success;
819   bool io;
820 } _Hbase_getTableNames_result__isset;
821 
822 class Hbase_getTableNames_result {
823  public:
824 
Hbase_getTableNames_result()825   Hbase_getTableNames_result() {
826   }
827 
~Hbase_getTableNames_result()828   virtual ~Hbase_getTableNames_result() throw() {}
829 
830   std::vector<Text>  success;
831   IOError io;
832 
833   _Hbase_getTableNames_result__isset __isset;
834 
__set_success(const std::vector<Text> & val)835   void __set_success(const std::vector<Text> & val) {
836     success = val;
837   }
838 
__set_io(const IOError & val)839   void __set_io(const IOError& val) {
840     io = val;
841   }
842 
843   bool operator == (const Hbase_getTableNames_result & rhs) const
844   {
845     if (!(success == rhs.success))
846       return false;
847     if (!(io == rhs.io))
848       return false;
849     return true;
850   }
851   bool operator != (const Hbase_getTableNames_result &rhs) const {
852     return !(*this == rhs);
853   }
854 
855   bool operator < (const Hbase_getTableNames_result & ) const;
856 
857   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
858   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
859 
860 };
861 
862 typedef struct _Hbase_getTableNames_presult__isset {
_Hbase_getTableNames_presult__isset_Hbase_getTableNames_presult__isset863   _Hbase_getTableNames_presult__isset() : success(false), io(false) {}
864   bool success;
865   bool io;
866 } _Hbase_getTableNames_presult__isset;
867 
868 class Hbase_getTableNames_presult {
869  public:
870 
871 
~Hbase_getTableNames_presult()872   virtual ~Hbase_getTableNames_presult() throw() {}
873 
874   std::vector<Text> * success;
875   IOError io;
876 
877   _Hbase_getTableNames_presult__isset __isset;
878 
879   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
880 
881 };
882 
883 typedef struct _Hbase_getColumnDescriptors_args__isset {
_Hbase_getColumnDescriptors_args__isset_Hbase_getColumnDescriptors_args__isset884   _Hbase_getColumnDescriptors_args__isset() : tableName(false) {}
885   bool tableName;
886 } _Hbase_getColumnDescriptors_args__isset;
887 
888 class Hbase_getColumnDescriptors_args {
889  public:
890 
Hbase_getColumnDescriptors_args()891   Hbase_getColumnDescriptors_args() : tableName() {
892   }
893 
~Hbase_getColumnDescriptors_args()894   virtual ~Hbase_getColumnDescriptors_args() throw() {}
895 
896   Text tableName;
897 
898   _Hbase_getColumnDescriptors_args__isset __isset;
899 
__set_tableName(const Text & val)900   void __set_tableName(const Text& val) {
901     tableName = val;
902   }
903 
904   bool operator == (const Hbase_getColumnDescriptors_args & rhs) const
905   {
906     if (!(tableName == rhs.tableName))
907       return false;
908     return true;
909   }
910   bool operator != (const Hbase_getColumnDescriptors_args &rhs) const {
911     return !(*this == rhs);
912   }
913 
914   bool operator < (const Hbase_getColumnDescriptors_args & ) const;
915 
916   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
917   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
918 
919 };
920 
921 
922 class Hbase_getColumnDescriptors_pargs {
923  public:
924 
925 
~Hbase_getColumnDescriptors_pargs()926   virtual ~Hbase_getColumnDescriptors_pargs() throw() {}
927 
928   const Text* tableName;
929 
930   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
931 
932 };
933 
934 typedef struct _Hbase_getColumnDescriptors_result__isset {
_Hbase_getColumnDescriptors_result__isset_Hbase_getColumnDescriptors_result__isset935   _Hbase_getColumnDescriptors_result__isset() : success(false), io(false) {}
936   bool success;
937   bool io;
938 } _Hbase_getColumnDescriptors_result__isset;
939 
940 class Hbase_getColumnDescriptors_result {
941  public:
942 
Hbase_getColumnDescriptors_result()943   Hbase_getColumnDescriptors_result() {
944   }
945 
~Hbase_getColumnDescriptors_result()946   virtual ~Hbase_getColumnDescriptors_result() throw() {}
947 
948   std::map<Text, ColumnDescriptor>  success;
949   IOError io;
950 
951   _Hbase_getColumnDescriptors_result__isset __isset;
952 
__set_success(const std::map<Text,ColumnDescriptor> & val)953   void __set_success(const std::map<Text, ColumnDescriptor> & val) {
954     success = val;
955   }
956 
__set_io(const IOError & val)957   void __set_io(const IOError& val) {
958     io = val;
959   }
960 
961   bool operator == (const Hbase_getColumnDescriptors_result & rhs) const
962   {
963     if (!(success == rhs.success))
964       return false;
965     if (!(io == rhs.io))
966       return false;
967     return true;
968   }
969   bool operator != (const Hbase_getColumnDescriptors_result &rhs) const {
970     return !(*this == rhs);
971   }
972 
973   bool operator < (const Hbase_getColumnDescriptors_result & ) const;
974 
975   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
976   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
977 
978 };
979 
980 typedef struct _Hbase_getColumnDescriptors_presult__isset {
_Hbase_getColumnDescriptors_presult__isset_Hbase_getColumnDescriptors_presult__isset981   _Hbase_getColumnDescriptors_presult__isset() : success(false), io(false) {}
982   bool success;
983   bool io;
984 } _Hbase_getColumnDescriptors_presult__isset;
985 
986 class Hbase_getColumnDescriptors_presult {
987  public:
988 
989 
~Hbase_getColumnDescriptors_presult()990   virtual ~Hbase_getColumnDescriptors_presult() throw() {}
991 
992   std::map<Text, ColumnDescriptor> * success;
993   IOError io;
994 
995   _Hbase_getColumnDescriptors_presult__isset __isset;
996 
997   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
998 
999 };
1000 
1001 typedef struct _Hbase_getTableRegions_args__isset {
_Hbase_getTableRegions_args__isset_Hbase_getTableRegions_args__isset1002   _Hbase_getTableRegions_args__isset() : tableName(false) {}
1003   bool tableName;
1004 } _Hbase_getTableRegions_args__isset;
1005 
1006 class Hbase_getTableRegions_args {
1007  public:
1008 
Hbase_getTableRegions_args()1009   Hbase_getTableRegions_args() : tableName() {
1010   }
1011 
~Hbase_getTableRegions_args()1012   virtual ~Hbase_getTableRegions_args() throw() {}
1013 
1014   Text tableName;
1015 
1016   _Hbase_getTableRegions_args__isset __isset;
1017 
__set_tableName(const Text & val)1018   void __set_tableName(const Text& val) {
1019     tableName = val;
1020   }
1021 
1022   bool operator == (const Hbase_getTableRegions_args & rhs) const
1023   {
1024     if (!(tableName == rhs.tableName))
1025       return false;
1026     return true;
1027   }
1028   bool operator != (const Hbase_getTableRegions_args &rhs) const {
1029     return !(*this == rhs);
1030   }
1031 
1032   bool operator < (const Hbase_getTableRegions_args & ) const;
1033 
1034   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1035   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1036 
1037 };
1038 
1039 
1040 class Hbase_getTableRegions_pargs {
1041  public:
1042 
1043 
~Hbase_getTableRegions_pargs()1044   virtual ~Hbase_getTableRegions_pargs() throw() {}
1045 
1046   const Text* tableName;
1047 
1048   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1049 
1050 };
1051 
1052 typedef struct _Hbase_getTableRegions_result__isset {
_Hbase_getTableRegions_result__isset_Hbase_getTableRegions_result__isset1053   _Hbase_getTableRegions_result__isset() : success(false), io(false) {}
1054   bool success;
1055   bool io;
1056 } _Hbase_getTableRegions_result__isset;
1057 
1058 class Hbase_getTableRegions_result {
1059  public:
1060 
Hbase_getTableRegions_result()1061   Hbase_getTableRegions_result() {
1062   }
1063 
~Hbase_getTableRegions_result()1064   virtual ~Hbase_getTableRegions_result() throw() {}
1065 
1066   std::vector<TRegionInfo>  success;
1067   IOError io;
1068 
1069   _Hbase_getTableRegions_result__isset __isset;
1070 
__set_success(const std::vector<TRegionInfo> & val)1071   void __set_success(const std::vector<TRegionInfo> & val) {
1072     success = val;
1073   }
1074 
__set_io(const IOError & val)1075   void __set_io(const IOError& val) {
1076     io = val;
1077   }
1078 
1079   bool operator == (const Hbase_getTableRegions_result & rhs) const
1080   {
1081     if (!(success == rhs.success))
1082       return false;
1083     if (!(io == rhs.io))
1084       return false;
1085     return true;
1086   }
1087   bool operator != (const Hbase_getTableRegions_result &rhs) const {
1088     return !(*this == rhs);
1089   }
1090 
1091   bool operator < (const Hbase_getTableRegions_result & ) const;
1092 
1093   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1094   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1095 
1096 };
1097 
1098 typedef struct _Hbase_getTableRegions_presult__isset {
_Hbase_getTableRegions_presult__isset_Hbase_getTableRegions_presult__isset1099   _Hbase_getTableRegions_presult__isset() : success(false), io(false) {}
1100   bool success;
1101   bool io;
1102 } _Hbase_getTableRegions_presult__isset;
1103 
1104 class Hbase_getTableRegions_presult {
1105  public:
1106 
1107 
~Hbase_getTableRegions_presult()1108   virtual ~Hbase_getTableRegions_presult() throw() {}
1109 
1110   std::vector<TRegionInfo> * success;
1111   IOError io;
1112 
1113   _Hbase_getTableRegions_presult__isset __isset;
1114 
1115   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1116 
1117 };
1118 
1119 typedef struct _Hbase_createTable_args__isset {
_Hbase_createTable_args__isset_Hbase_createTable_args__isset1120   _Hbase_createTable_args__isset() : tableName(false), columnFamilies(false) {}
1121   bool tableName;
1122   bool columnFamilies;
1123 } _Hbase_createTable_args__isset;
1124 
1125 class Hbase_createTable_args {
1126  public:
1127 
Hbase_createTable_args()1128   Hbase_createTable_args() : tableName() {
1129   }
1130 
~Hbase_createTable_args()1131   virtual ~Hbase_createTable_args() throw() {}
1132 
1133   Text tableName;
1134   std::vector<ColumnDescriptor>  columnFamilies;
1135 
1136   _Hbase_createTable_args__isset __isset;
1137 
__set_tableName(const Text & val)1138   void __set_tableName(const Text& val) {
1139     tableName = val;
1140   }
1141 
__set_columnFamilies(const std::vector<ColumnDescriptor> & val)1142   void __set_columnFamilies(const std::vector<ColumnDescriptor> & val) {
1143     columnFamilies = val;
1144   }
1145 
1146   bool operator == (const Hbase_createTable_args & rhs) const
1147   {
1148     if (!(tableName == rhs.tableName))
1149       return false;
1150     if (!(columnFamilies == rhs.columnFamilies))
1151       return false;
1152     return true;
1153   }
1154   bool operator != (const Hbase_createTable_args &rhs) const {
1155     return !(*this == rhs);
1156   }
1157 
1158   bool operator < (const Hbase_createTable_args & ) const;
1159 
1160   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1161   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1162 
1163 };
1164 
1165 
1166 class Hbase_createTable_pargs {
1167  public:
1168 
1169 
~Hbase_createTable_pargs()1170   virtual ~Hbase_createTable_pargs() throw() {}
1171 
1172   const Text* tableName;
1173   const std::vector<ColumnDescriptor> * columnFamilies;
1174 
1175   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1176 
1177 };
1178 
1179 typedef struct _Hbase_createTable_result__isset {
_Hbase_createTable_result__isset_Hbase_createTable_result__isset1180   _Hbase_createTable_result__isset() : io(false), ia(false), exist(false) {}
1181   bool io;
1182   bool ia;
1183   bool exist;
1184 } _Hbase_createTable_result__isset;
1185 
1186 class Hbase_createTable_result {
1187  public:
1188 
Hbase_createTable_result()1189   Hbase_createTable_result() {
1190   }
1191 
~Hbase_createTable_result()1192   virtual ~Hbase_createTable_result() throw() {}
1193 
1194   IOError io;
1195   IllegalArgument ia;
1196   AlreadyExists exist;
1197 
1198   _Hbase_createTable_result__isset __isset;
1199 
__set_io(const IOError & val)1200   void __set_io(const IOError& val) {
1201     io = val;
1202   }
1203 
__set_ia(const IllegalArgument & val)1204   void __set_ia(const IllegalArgument& val) {
1205     ia = val;
1206   }
1207 
__set_exist(const AlreadyExists & val)1208   void __set_exist(const AlreadyExists& val) {
1209     exist = val;
1210   }
1211 
1212   bool operator == (const Hbase_createTable_result & rhs) const
1213   {
1214     if (!(io == rhs.io))
1215       return false;
1216     if (!(ia == rhs.ia))
1217       return false;
1218     if (!(exist == rhs.exist))
1219       return false;
1220     return true;
1221   }
1222   bool operator != (const Hbase_createTable_result &rhs) const {
1223     return !(*this == rhs);
1224   }
1225 
1226   bool operator < (const Hbase_createTable_result & ) const;
1227 
1228   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1229   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1230 
1231 };
1232 
1233 typedef struct _Hbase_createTable_presult__isset {
_Hbase_createTable_presult__isset_Hbase_createTable_presult__isset1234   _Hbase_createTable_presult__isset() : io(false), ia(false), exist(false) {}
1235   bool io;
1236   bool ia;
1237   bool exist;
1238 } _Hbase_createTable_presult__isset;
1239 
1240 class Hbase_createTable_presult {
1241  public:
1242 
1243 
~Hbase_createTable_presult()1244   virtual ~Hbase_createTable_presult() throw() {}
1245 
1246   IOError io;
1247   IllegalArgument ia;
1248   AlreadyExists exist;
1249 
1250   _Hbase_createTable_presult__isset __isset;
1251 
1252   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1253 
1254 };
1255 
1256 typedef struct _Hbase_deleteTable_args__isset {
_Hbase_deleteTable_args__isset_Hbase_deleteTable_args__isset1257   _Hbase_deleteTable_args__isset() : tableName(false) {}
1258   bool tableName;
1259 } _Hbase_deleteTable_args__isset;
1260 
1261 class Hbase_deleteTable_args {
1262  public:
1263 
Hbase_deleteTable_args()1264   Hbase_deleteTable_args() : tableName() {
1265   }
1266 
~Hbase_deleteTable_args()1267   virtual ~Hbase_deleteTable_args() throw() {}
1268 
1269   Text tableName;
1270 
1271   _Hbase_deleteTable_args__isset __isset;
1272 
__set_tableName(const Text & val)1273   void __set_tableName(const Text& val) {
1274     tableName = val;
1275   }
1276 
1277   bool operator == (const Hbase_deleteTable_args & rhs) const
1278   {
1279     if (!(tableName == rhs.tableName))
1280       return false;
1281     return true;
1282   }
1283   bool operator != (const Hbase_deleteTable_args &rhs) const {
1284     return !(*this == rhs);
1285   }
1286 
1287   bool operator < (const Hbase_deleteTable_args & ) const;
1288 
1289   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1290   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1291 
1292 };
1293 
1294 
1295 class Hbase_deleteTable_pargs {
1296  public:
1297 
1298 
~Hbase_deleteTable_pargs()1299   virtual ~Hbase_deleteTable_pargs() throw() {}
1300 
1301   const Text* tableName;
1302 
1303   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1304 
1305 };
1306 
1307 typedef struct _Hbase_deleteTable_result__isset {
_Hbase_deleteTable_result__isset_Hbase_deleteTable_result__isset1308   _Hbase_deleteTable_result__isset() : io(false) {}
1309   bool io;
1310 } _Hbase_deleteTable_result__isset;
1311 
1312 class Hbase_deleteTable_result {
1313  public:
1314 
Hbase_deleteTable_result()1315   Hbase_deleteTable_result() {
1316   }
1317 
~Hbase_deleteTable_result()1318   virtual ~Hbase_deleteTable_result() throw() {}
1319 
1320   IOError io;
1321 
1322   _Hbase_deleteTable_result__isset __isset;
1323 
__set_io(const IOError & val)1324   void __set_io(const IOError& val) {
1325     io = val;
1326   }
1327 
1328   bool operator == (const Hbase_deleteTable_result & rhs) const
1329   {
1330     if (!(io == rhs.io))
1331       return false;
1332     return true;
1333   }
1334   bool operator != (const Hbase_deleteTable_result &rhs) const {
1335     return !(*this == rhs);
1336   }
1337 
1338   bool operator < (const Hbase_deleteTable_result & ) const;
1339 
1340   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1341   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1342 
1343 };
1344 
1345 typedef struct _Hbase_deleteTable_presult__isset {
_Hbase_deleteTable_presult__isset_Hbase_deleteTable_presult__isset1346   _Hbase_deleteTable_presult__isset() : io(false) {}
1347   bool io;
1348 } _Hbase_deleteTable_presult__isset;
1349 
1350 class Hbase_deleteTable_presult {
1351  public:
1352 
1353 
~Hbase_deleteTable_presult()1354   virtual ~Hbase_deleteTable_presult() throw() {}
1355 
1356   IOError io;
1357 
1358   _Hbase_deleteTable_presult__isset __isset;
1359 
1360   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1361 
1362 };
1363 
1364 typedef struct _Hbase_get_args__isset {
_Hbase_get_args__isset_Hbase_get_args__isset1365   _Hbase_get_args__isset() : tableName(false), row(false), column(false), attributes(false) {}
1366   bool tableName;
1367   bool row;
1368   bool column;
1369   bool attributes;
1370 } _Hbase_get_args__isset;
1371 
1372 class Hbase_get_args {
1373  public:
1374 
Hbase_get_args()1375   Hbase_get_args() : tableName(), row(), column() {
1376   }
1377 
~Hbase_get_args()1378   virtual ~Hbase_get_args() throw() {}
1379 
1380   Text tableName;
1381   Text row;
1382   Text column;
1383   std::map<Text, Text>  attributes;
1384 
1385   _Hbase_get_args__isset __isset;
1386 
__set_tableName(const Text & val)1387   void __set_tableName(const Text& val) {
1388     tableName = val;
1389   }
1390 
__set_row(const Text & val)1391   void __set_row(const Text& val) {
1392     row = val;
1393   }
1394 
__set_column(const Text & val)1395   void __set_column(const Text& val) {
1396     column = val;
1397   }
1398 
__set_attributes(const std::map<Text,Text> & val)1399   void __set_attributes(const std::map<Text, Text> & val) {
1400     attributes = val;
1401   }
1402 
1403   bool operator == (const Hbase_get_args & rhs) const
1404   {
1405     if (!(tableName == rhs.tableName))
1406       return false;
1407     if (!(row == rhs.row))
1408       return false;
1409     if (!(column == rhs.column))
1410       return false;
1411     if (!(attributes == rhs.attributes))
1412       return false;
1413     return true;
1414   }
1415   bool operator != (const Hbase_get_args &rhs) const {
1416     return !(*this == rhs);
1417   }
1418 
1419   bool operator < (const Hbase_get_args & ) const;
1420 
1421   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1422   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1423 
1424 };
1425 
1426 
1427 class Hbase_get_pargs {
1428  public:
1429 
1430 
~Hbase_get_pargs()1431   virtual ~Hbase_get_pargs() throw() {}
1432 
1433   const Text* tableName;
1434   const Text* row;
1435   const Text* column;
1436   const std::map<Text, Text> * attributes;
1437 
1438   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1439 
1440 };
1441 
1442 typedef struct _Hbase_get_result__isset {
_Hbase_get_result__isset_Hbase_get_result__isset1443   _Hbase_get_result__isset() : success(false), io(false) {}
1444   bool success;
1445   bool io;
1446 } _Hbase_get_result__isset;
1447 
1448 class Hbase_get_result {
1449  public:
1450 
Hbase_get_result()1451   Hbase_get_result() {
1452   }
1453 
~Hbase_get_result()1454   virtual ~Hbase_get_result() throw() {}
1455 
1456   std::vector<TCell>  success;
1457   IOError io;
1458 
1459   _Hbase_get_result__isset __isset;
1460 
__set_success(const std::vector<TCell> & val)1461   void __set_success(const std::vector<TCell> & val) {
1462     success = val;
1463   }
1464 
__set_io(const IOError & val)1465   void __set_io(const IOError& val) {
1466     io = val;
1467   }
1468 
1469   bool operator == (const Hbase_get_result & rhs) const
1470   {
1471     if (!(success == rhs.success))
1472       return false;
1473     if (!(io == rhs.io))
1474       return false;
1475     return true;
1476   }
1477   bool operator != (const Hbase_get_result &rhs) const {
1478     return !(*this == rhs);
1479   }
1480 
1481   bool operator < (const Hbase_get_result & ) const;
1482 
1483   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1484   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1485 
1486 };
1487 
1488 typedef struct _Hbase_get_presult__isset {
_Hbase_get_presult__isset_Hbase_get_presult__isset1489   _Hbase_get_presult__isset() : success(false), io(false) {}
1490   bool success;
1491   bool io;
1492 } _Hbase_get_presult__isset;
1493 
1494 class Hbase_get_presult {
1495  public:
1496 
1497 
~Hbase_get_presult()1498   virtual ~Hbase_get_presult() throw() {}
1499 
1500   std::vector<TCell> * success;
1501   IOError io;
1502 
1503   _Hbase_get_presult__isset __isset;
1504 
1505   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1506 
1507 };
1508 
1509 typedef struct _Hbase_getVer_args__isset {
_Hbase_getVer_args__isset_Hbase_getVer_args__isset1510   _Hbase_getVer_args__isset() : tableName(false), row(false), column(false), numVersions(false), attributes(false) {}
1511   bool tableName;
1512   bool row;
1513   bool column;
1514   bool numVersions;
1515   bool attributes;
1516 } _Hbase_getVer_args__isset;
1517 
1518 class Hbase_getVer_args {
1519  public:
1520 
Hbase_getVer_args()1521   Hbase_getVer_args() : tableName(), row(), column(), numVersions(0) {
1522   }
1523 
~Hbase_getVer_args()1524   virtual ~Hbase_getVer_args() throw() {}
1525 
1526   Text tableName;
1527   Text row;
1528   Text column;
1529   int32_t numVersions;
1530   std::map<Text, Text>  attributes;
1531 
1532   _Hbase_getVer_args__isset __isset;
1533 
__set_tableName(const Text & val)1534   void __set_tableName(const Text& val) {
1535     tableName = val;
1536   }
1537 
__set_row(const Text & val)1538   void __set_row(const Text& val) {
1539     row = val;
1540   }
1541 
__set_column(const Text & val)1542   void __set_column(const Text& val) {
1543     column = val;
1544   }
1545 
__set_numVersions(const int32_t val)1546   void __set_numVersions(const int32_t val) {
1547     numVersions = val;
1548   }
1549 
__set_attributes(const std::map<Text,Text> & val)1550   void __set_attributes(const std::map<Text, Text> & val) {
1551     attributes = val;
1552   }
1553 
1554   bool operator == (const Hbase_getVer_args & rhs) const
1555   {
1556     if (!(tableName == rhs.tableName))
1557       return false;
1558     if (!(row == rhs.row))
1559       return false;
1560     if (!(column == rhs.column))
1561       return false;
1562     if (!(numVersions == rhs.numVersions))
1563       return false;
1564     if (!(attributes == rhs.attributes))
1565       return false;
1566     return true;
1567   }
1568   bool operator != (const Hbase_getVer_args &rhs) const {
1569     return !(*this == rhs);
1570   }
1571 
1572   bool operator < (const Hbase_getVer_args & ) const;
1573 
1574   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1575   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1576 
1577 };
1578 
1579 
1580 class Hbase_getVer_pargs {
1581  public:
1582 
1583 
~Hbase_getVer_pargs()1584   virtual ~Hbase_getVer_pargs() throw() {}
1585 
1586   const Text* tableName;
1587   const Text* row;
1588   const Text* column;
1589   const int32_t* numVersions;
1590   const std::map<Text, Text> * attributes;
1591 
1592   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1593 
1594 };
1595 
1596 typedef struct _Hbase_getVer_result__isset {
_Hbase_getVer_result__isset_Hbase_getVer_result__isset1597   _Hbase_getVer_result__isset() : success(false), io(false) {}
1598   bool success;
1599   bool io;
1600 } _Hbase_getVer_result__isset;
1601 
1602 class Hbase_getVer_result {
1603  public:
1604 
Hbase_getVer_result()1605   Hbase_getVer_result() {
1606   }
1607 
~Hbase_getVer_result()1608   virtual ~Hbase_getVer_result() throw() {}
1609 
1610   std::vector<TCell>  success;
1611   IOError io;
1612 
1613   _Hbase_getVer_result__isset __isset;
1614 
__set_success(const std::vector<TCell> & val)1615   void __set_success(const std::vector<TCell> & val) {
1616     success = val;
1617   }
1618 
__set_io(const IOError & val)1619   void __set_io(const IOError& val) {
1620     io = val;
1621   }
1622 
1623   bool operator == (const Hbase_getVer_result & rhs) const
1624   {
1625     if (!(success == rhs.success))
1626       return false;
1627     if (!(io == rhs.io))
1628       return false;
1629     return true;
1630   }
1631   bool operator != (const Hbase_getVer_result &rhs) const {
1632     return !(*this == rhs);
1633   }
1634 
1635   bool operator < (const Hbase_getVer_result & ) const;
1636 
1637   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1638   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1639 
1640 };
1641 
1642 typedef struct _Hbase_getVer_presult__isset {
_Hbase_getVer_presult__isset_Hbase_getVer_presult__isset1643   _Hbase_getVer_presult__isset() : success(false), io(false) {}
1644   bool success;
1645   bool io;
1646 } _Hbase_getVer_presult__isset;
1647 
1648 class Hbase_getVer_presult {
1649  public:
1650 
1651 
~Hbase_getVer_presult()1652   virtual ~Hbase_getVer_presult() throw() {}
1653 
1654   std::vector<TCell> * success;
1655   IOError io;
1656 
1657   _Hbase_getVer_presult__isset __isset;
1658 
1659   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1660 
1661 };
1662 
1663 typedef struct _Hbase_getVerTs_args__isset {
_Hbase_getVerTs_args__isset_Hbase_getVerTs_args__isset1664   _Hbase_getVerTs_args__isset() : tableName(false), row(false), column(false), timestamp(false), numVersions(false), attributes(false) {}
1665   bool tableName;
1666   bool row;
1667   bool column;
1668   bool timestamp;
1669   bool numVersions;
1670   bool attributes;
1671 } _Hbase_getVerTs_args__isset;
1672 
1673 class Hbase_getVerTs_args {
1674  public:
1675 
Hbase_getVerTs_args()1676   Hbase_getVerTs_args() : tableName(), row(), column(), timestamp(0), numVersions(0) {
1677   }
1678 
~Hbase_getVerTs_args()1679   virtual ~Hbase_getVerTs_args() throw() {}
1680 
1681   Text tableName;
1682   Text row;
1683   Text column;
1684   int64_t timestamp;
1685   int32_t numVersions;
1686   std::map<Text, Text>  attributes;
1687 
1688   _Hbase_getVerTs_args__isset __isset;
1689 
__set_tableName(const Text & val)1690   void __set_tableName(const Text& val) {
1691     tableName = val;
1692   }
1693 
__set_row(const Text & val)1694   void __set_row(const Text& val) {
1695     row = val;
1696   }
1697 
__set_column(const Text & val)1698   void __set_column(const Text& val) {
1699     column = val;
1700   }
1701 
__set_timestamp(const int64_t val)1702   void __set_timestamp(const int64_t val) {
1703     timestamp = val;
1704   }
1705 
__set_numVersions(const int32_t val)1706   void __set_numVersions(const int32_t val) {
1707     numVersions = val;
1708   }
1709 
__set_attributes(const std::map<Text,Text> & val)1710   void __set_attributes(const std::map<Text, Text> & val) {
1711     attributes = val;
1712   }
1713 
1714   bool operator == (const Hbase_getVerTs_args & rhs) const
1715   {
1716     if (!(tableName == rhs.tableName))
1717       return false;
1718     if (!(row == rhs.row))
1719       return false;
1720     if (!(column == rhs.column))
1721       return false;
1722     if (!(timestamp == rhs.timestamp))
1723       return false;
1724     if (!(numVersions == rhs.numVersions))
1725       return false;
1726     if (!(attributes == rhs.attributes))
1727       return false;
1728     return true;
1729   }
1730   bool operator != (const Hbase_getVerTs_args &rhs) const {
1731     return !(*this == rhs);
1732   }
1733 
1734   bool operator < (const Hbase_getVerTs_args & ) const;
1735 
1736   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1737   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1738 
1739 };
1740 
1741 
1742 class Hbase_getVerTs_pargs {
1743  public:
1744 
1745 
~Hbase_getVerTs_pargs()1746   virtual ~Hbase_getVerTs_pargs() throw() {}
1747 
1748   const Text* tableName;
1749   const Text* row;
1750   const Text* column;
1751   const int64_t* timestamp;
1752   const int32_t* numVersions;
1753   const std::map<Text, Text> * attributes;
1754 
1755   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1756 
1757 };
1758 
1759 typedef struct _Hbase_getVerTs_result__isset {
_Hbase_getVerTs_result__isset_Hbase_getVerTs_result__isset1760   _Hbase_getVerTs_result__isset() : success(false), io(false) {}
1761   bool success;
1762   bool io;
1763 } _Hbase_getVerTs_result__isset;
1764 
1765 class Hbase_getVerTs_result {
1766  public:
1767 
Hbase_getVerTs_result()1768   Hbase_getVerTs_result() {
1769   }
1770 
~Hbase_getVerTs_result()1771   virtual ~Hbase_getVerTs_result() throw() {}
1772 
1773   std::vector<TCell>  success;
1774   IOError io;
1775 
1776   _Hbase_getVerTs_result__isset __isset;
1777 
__set_success(const std::vector<TCell> & val)1778   void __set_success(const std::vector<TCell> & val) {
1779     success = val;
1780   }
1781 
__set_io(const IOError & val)1782   void __set_io(const IOError& val) {
1783     io = val;
1784   }
1785 
1786   bool operator == (const Hbase_getVerTs_result & rhs) const
1787   {
1788     if (!(success == rhs.success))
1789       return false;
1790     if (!(io == rhs.io))
1791       return false;
1792     return true;
1793   }
1794   bool operator != (const Hbase_getVerTs_result &rhs) const {
1795     return !(*this == rhs);
1796   }
1797 
1798   bool operator < (const Hbase_getVerTs_result & ) const;
1799 
1800   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1801   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1802 
1803 };
1804 
1805 typedef struct _Hbase_getVerTs_presult__isset {
_Hbase_getVerTs_presult__isset_Hbase_getVerTs_presult__isset1806   _Hbase_getVerTs_presult__isset() : success(false), io(false) {}
1807   bool success;
1808   bool io;
1809 } _Hbase_getVerTs_presult__isset;
1810 
1811 class Hbase_getVerTs_presult {
1812  public:
1813 
1814 
~Hbase_getVerTs_presult()1815   virtual ~Hbase_getVerTs_presult() throw() {}
1816 
1817   std::vector<TCell> * success;
1818   IOError io;
1819 
1820   _Hbase_getVerTs_presult__isset __isset;
1821 
1822   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1823 
1824 };
1825 
1826 typedef struct _Hbase_getRow_args__isset {
_Hbase_getRow_args__isset_Hbase_getRow_args__isset1827   _Hbase_getRow_args__isset() : tableName(false), row(false), attributes(false) {}
1828   bool tableName;
1829   bool row;
1830   bool attributes;
1831 } _Hbase_getRow_args__isset;
1832 
1833 class Hbase_getRow_args {
1834  public:
1835 
Hbase_getRow_args()1836   Hbase_getRow_args() : tableName(), row() {
1837   }
1838 
~Hbase_getRow_args()1839   virtual ~Hbase_getRow_args() throw() {}
1840 
1841   Text tableName;
1842   Text row;
1843   std::map<Text, Text>  attributes;
1844 
1845   _Hbase_getRow_args__isset __isset;
1846 
__set_tableName(const Text & val)1847   void __set_tableName(const Text& val) {
1848     tableName = val;
1849   }
1850 
__set_row(const Text & val)1851   void __set_row(const Text& val) {
1852     row = val;
1853   }
1854 
__set_attributes(const std::map<Text,Text> & val)1855   void __set_attributes(const std::map<Text, Text> & val) {
1856     attributes = val;
1857   }
1858 
1859   bool operator == (const Hbase_getRow_args & rhs) const
1860   {
1861     if (!(tableName == rhs.tableName))
1862       return false;
1863     if (!(row == rhs.row))
1864       return false;
1865     if (!(attributes == rhs.attributes))
1866       return false;
1867     return true;
1868   }
1869   bool operator != (const Hbase_getRow_args &rhs) const {
1870     return !(*this == rhs);
1871   }
1872 
1873   bool operator < (const Hbase_getRow_args & ) const;
1874 
1875   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1876   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1877 
1878 };
1879 
1880 
1881 class Hbase_getRow_pargs {
1882  public:
1883 
1884 
~Hbase_getRow_pargs()1885   virtual ~Hbase_getRow_pargs() throw() {}
1886 
1887   const Text* tableName;
1888   const Text* row;
1889   const std::map<Text, Text> * attributes;
1890 
1891   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1892 
1893 };
1894 
1895 typedef struct _Hbase_getRow_result__isset {
_Hbase_getRow_result__isset_Hbase_getRow_result__isset1896   _Hbase_getRow_result__isset() : success(false), io(false) {}
1897   bool success;
1898   bool io;
1899 } _Hbase_getRow_result__isset;
1900 
1901 class Hbase_getRow_result {
1902  public:
1903 
Hbase_getRow_result()1904   Hbase_getRow_result() {
1905   }
1906 
~Hbase_getRow_result()1907   virtual ~Hbase_getRow_result() throw() {}
1908 
1909   std::vector<TRowResult>  success;
1910   IOError io;
1911 
1912   _Hbase_getRow_result__isset __isset;
1913 
__set_success(const std::vector<TRowResult> & val)1914   void __set_success(const std::vector<TRowResult> & val) {
1915     success = val;
1916   }
1917 
__set_io(const IOError & val)1918   void __set_io(const IOError& val) {
1919     io = val;
1920   }
1921 
1922   bool operator == (const Hbase_getRow_result & rhs) const
1923   {
1924     if (!(success == rhs.success))
1925       return false;
1926     if (!(io == rhs.io))
1927       return false;
1928     return true;
1929   }
1930   bool operator != (const Hbase_getRow_result &rhs) const {
1931     return !(*this == rhs);
1932   }
1933 
1934   bool operator < (const Hbase_getRow_result & ) const;
1935 
1936   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1937   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
1938 
1939 };
1940 
1941 typedef struct _Hbase_getRow_presult__isset {
_Hbase_getRow_presult__isset_Hbase_getRow_presult__isset1942   _Hbase_getRow_presult__isset() : success(false), io(false) {}
1943   bool success;
1944   bool io;
1945 } _Hbase_getRow_presult__isset;
1946 
1947 class Hbase_getRow_presult {
1948  public:
1949 
1950 
~Hbase_getRow_presult()1951   virtual ~Hbase_getRow_presult() throw() {}
1952 
1953   std::vector<TRowResult> * success;
1954   IOError io;
1955 
1956   _Hbase_getRow_presult__isset __isset;
1957 
1958   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
1959 
1960 };
1961 
1962 typedef struct _Hbase_getRowWithColumns_args__isset {
_Hbase_getRowWithColumns_args__isset_Hbase_getRowWithColumns_args__isset1963   _Hbase_getRowWithColumns_args__isset() : tableName(false), row(false), columns(false), attributes(false) {}
1964   bool tableName;
1965   bool row;
1966   bool columns;
1967   bool attributes;
1968 } _Hbase_getRowWithColumns_args__isset;
1969 
1970 class Hbase_getRowWithColumns_args {
1971  public:
1972 
Hbase_getRowWithColumns_args()1973   Hbase_getRowWithColumns_args() : tableName(), row() {
1974   }
1975 
~Hbase_getRowWithColumns_args()1976   virtual ~Hbase_getRowWithColumns_args() throw() {}
1977 
1978   Text tableName;
1979   Text row;
1980   std::vector<Text>  columns;
1981   std::map<Text, Text>  attributes;
1982 
1983   _Hbase_getRowWithColumns_args__isset __isset;
1984 
__set_tableName(const Text & val)1985   void __set_tableName(const Text& val) {
1986     tableName = val;
1987   }
1988 
__set_row(const Text & val)1989   void __set_row(const Text& val) {
1990     row = val;
1991   }
1992 
__set_columns(const std::vector<Text> & val)1993   void __set_columns(const std::vector<Text> & val) {
1994     columns = val;
1995   }
1996 
__set_attributes(const std::map<Text,Text> & val)1997   void __set_attributes(const std::map<Text, Text> & val) {
1998     attributes = val;
1999   }
2000 
2001   bool operator == (const Hbase_getRowWithColumns_args & rhs) const
2002   {
2003     if (!(tableName == rhs.tableName))
2004       return false;
2005     if (!(row == rhs.row))
2006       return false;
2007     if (!(columns == rhs.columns))
2008       return false;
2009     if (!(attributes == rhs.attributes))
2010       return false;
2011     return true;
2012   }
2013   bool operator != (const Hbase_getRowWithColumns_args &rhs) const {
2014     return !(*this == rhs);
2015   }
2016 
2017   bool operator < (const Hbase_getRowWithColumns_args & ) const;
2018 
2019   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2020   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2021 
2022 };
2023 
2024 
2025 class Hbase_getRowWithColumns_pargs {
2026  public:
2027 
2028 
~Hbase_getRowWithColumns_pargs()2029   virtual ~Hbase_getRowWithColumns_pargs() throw() {}
2030 
2031   const Text* tableName;
2032   const Text* row;
2033   const std::vector<Text> * columns;
2034   const std::map<Text, Text> * attributes;
2035 
2036   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2037 
2038 };
2039 
2040 typedef struct _Hbase_getRowWithColumns_result__isset {
_Hbase_getRowWithColumns_result__isset_Hbase_getRowWithColumns_result__isset2041   _Hbase_getRowWithColumns_result__isset() : success(false), io(false) {}
2042   bool success;
2043   bool io;
2044 } _Hbase_getRowWithColumns_result__isset;
2045 
2046 class Hbase_getRowWithColumns_result {
2047  public:
2048 
Hbase_getRowWithColumns_result()2049   Hbase_getRowWithColumns_result() {
2050   }
2051 
~Hbase_getRowWithColumns_result()2052   virtual ~Hbase_getRowWithColumns_result() throw() {}
2053 
2054   std::vector<TRowResult>  success;
2055   IOError io;
2056 
2057   _Hbase_getRowWithColumns_result__isset __isset;
2058 
__set_success(const std::vector<TRowResult> & val)2059   void __set_success(const std::vector<TRowResult> & val) {
2060     success = val;
2061   }
2062 
__set_io(const IOError & val)2063   void __set_io(const IOError& val) {
2064     io = val;
2065   }
2066 
2067   bool operator == (const Hbase_getRowWithColumns_result & rhs) const
2068   {
2069     if (!(success == rhs.success))
2070       return false;
2071     if (!(io == rhs.io))
2072       return false;
2073     return true;
2074   }
2075   bool operator != (const Hbase_getRowWithColumns_result &rhs) const {
2076     return !(*this == rhs);
2077   }
2078 
2079   bool operator < (const Hbase_getRowWithColumns_result & ) const;
2080 
2081   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2082   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2083 
2084 };
2085 
2086 typedef struct _Hbase_getRowWithColumns_presult__isset {
_Hbase_getRowWithColumns_presult__isset_Hbase_getRowWithColumns_presult__isset2087   _Hbase_getRowWithColumns_presult__isset() : success(false), io(false) {}
2088   bool success;
2089   bool io;
2090 } _Hbase_getRowWithColumns_presult__isset;
2091 
2092 class Hbase_getRowWithColumns_presult {
2093  public:
2094 
2095 
~Hbase_getRowWithColumns_presult()2096   virtual ~Hbase_getRowWithColumns_presult() throw() {}
2097 
2098   std::vector<TRowResult> * success;
2099   IOError io;
2100 
2101   _Hbase_getRowWithColumns_presult__isset __isset;
2102 
2103   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2104 
2105 };
2106 
2107 typedef struct _Hbase_getRowTs_args__isset {
_Hbase_getRowTs_args__isset_Hbase_getRowTs_args__isset2108   _Hbase_getRowTs_args__isset() : tableName(false), row(false), timestamp(false), attributes(false) {}
2109   bool tableName;
2110   bool row;
2111   bool timestamp;
2112   bool attributes;
2113 } _Hbase_getRowTs_args__isset;
2114 
2115 class Hbase_getRowTs_args {
2116  public:
2117 
Hbase_getRowTs_args()2118   Hbase_getRowTs_args() : tableName(), row(), timestamp(0) {
2119   }
2120 
~Hbase_getRowTs_args()2121   virtual ~Hbase_getRowTs_args() throw() {}
2122 
2123   Text tableName;
2124   Text row;
2125   int64_t timestamp;
2126   std::map<Text, Text>  attributes;
2127 
2128   _Hbase_getRowTs_args__isset __isset;
2129 
__set_tableName(const Text & val)2130   void __set_tableName(const Text& val) {
2131     tableName = val;
2132   }
2133 
__set_row(const Text & val)2134   void __set_row(const Text& val) {
2135     row = val;
2136   }
2137 
__set_timestamp(const int64_t val)2138   void __set_timestamp(const int64_t val) {
2139     timestamp = val;
2140   }
2141 
__set_attributes(const std::map<Text,Text> & val)2142   void __set_attributes(const std::map<Text, Text> & val) {
2143     attributes = val;
2144   }
2145 
2146   bool operator == (const Hbase_getRowTs_args & rhs) const
2147   {
2148     if (!(tableName == rhs.tableName))
2149       return false;
2150     if (!(row == rhs.row))
2151       return false;
2152     if (!(timestamp == rhs.timestamp))
2153       return false;
2154     if (!(attributes == rhs.attributes))
2155       return false;
2156     return true;
2157   }
2158   bool operator != (const Hbase_getRowTs_args &rhs) const {
2159     return !(*this == rhs);
2160   }
2161 
2162   bool operator < (const Hbase_getRowTs_args & ) const;
2163 
2164   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2165   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2166 
2167 };
2168 
2169 
2170 class Hbase_getRowTs_pargs {
2171  public:
2172 
2173 
~Hbase_getRowTs_pargs()2174   virtual ~Hbase_getRowTs_pargs() throw() {}
2175 
2176   const Text* tableName;
2177   const Text* row;
2178   const int64_t* timestamp;
2179   const std::map<Text, Text> * attributes;
2180 
2181   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2182 
2183 };
2184 
2185 typedef struct _Hbase_getRowTs_result__isset {
_Hbase_getRowTs_result__isset_Hbase_getRowTs_result__isset2186   _Hbase_getRowTs_result__isset() : success(false), io(false) {}
2187   bool success;
2188   bool io;
2189 } _Hbase_getRowTs_result__isset;
2190 
2191 class Hbase_getRowTs_result {
2192  public:
2193 
Hbase_getRowTs_result()2194   Hbase_getRowTs_result() {
2195   }
2196 
~Hbase_getRowTs_result()2197   virtual ~Hbase_getRowTs_result() throw() {}
2198 
2199   std::vector<TRowResult>  success;
2200   IOError io;
2201 
2202   _Hbase_getRowTs_result__isset __isset;
2203 
__set_success(const std::vector<TRowResult> & val)2204   void __set_success(const std::vector<TRowResult> & val) {
2205     success = val;
2206   }
2207 
__set_io(const IOError & val)2208   void __set_io(const IOError& val) {
2209     io = val;
2210   }
2211 
2212   bool operator == (const Hbase_getRowTs_result & rhs) const
2213   {
2214     if (!(success == rhs.success))
2215       return false;
2216     if (!(io == rhs.io))
2217       return false;
2218     return true;
2219   }
2220   bool operator != (const Hbase_getRowTs_result &rhs) const {
2221     return !(*this == rhs);
2222   }
2223 
2224   bool operator < (const Hbase_getRowTs_result & ) const;
2225 
2226   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2227   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2228 
2229 };
2230 
2231 typedef struct _Hbase_getRowTs_presult__isset {
_Hbase_getRowTs_presult__isset_Hbase_getRowTs_presult__isset2232   _Hbase_getRowTs_presult__isset() : success(false), io(false) {}
2233   bool success;
2234   bool io;
2235 } _Hbase_getRowTs_presult__isset;
2236 
2237 class Hbase_getRowTs_presult {
2238  public:
2239 
2240 
~Hbase_getRowTs_presult()2241   virtual ~Hbase_getRowTs_presult() throw() {}
2242 
2243   std::vector<TRowResult> * success;
2244   IOError io;
2245 
2246   _Hbase_getRowTs_presult__isset __isset;
2247 
2248   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2249 
2250 };
2251 
2252 typedef struct _Hbase_getRowWithColumnsTs_args__isset {
_Hbase_getRowWithColumnsTs_args__isset_Hbase_getRowWithColumnsTs_args__isset2253   _Hbase_getRowWithColumnsTs_args__isset() : tableName(false), row(false), columns(false), timestamp(false), attributes(false) {}
2254   bool tableName;
2255   bool row;
2256   bool columns;
2257   bool timestamp;
2258   bool attributes;
2259 } _Hbase_getRowWithColumnsTs_args__isset;
2260 
2261 class Hbase_getRowWithColumnsTs_args {
2262  public:
2263 
Hbase_getRowWithColumnsTs_args()2264   Hbase_getRowWithColumnsTs_args() : tableName(), row(), timestamp(0) {
2265   }
2266 
~Hbase_getRowWithColumnsTs_args()2267   virtual ~Hbase_getRowWithColumnsTs_args() throw() {}
2268 
2269   Text tableName;
2270   Text row;
2271   std::vector<Text>  columns;
2272   int64_t timestamp;
2273   std::map<Text, Text>  attributes;
2274 
2275   _Hbase_getRowWithColumnsTs_args__isset __isset;
2276 
__set_tableName(const Text & val)2277   void __set_tableName(const Text& val) {
2278     tableName = val;
2279   }
2280 
__set_row(const Text & val)2281   void __set_row(const Text& val) {
2282     row = val;
2283   }
2284 
__set_columns(const std::vector<Text> & val)2285   void __set_columns(const std::vector<Text> & val) {
2286     columns = val;
2287   }
2288 
__set_timestamp(const int64_t val)2289   void __set_timestamp(const int64_t val) {
2290     timestamp = val;
2291   }
2292 
__set_attributes(const std::map<Text,Text> & val)2293   void __set_attributes(const std::map<Text, Text> & val) {
2294     attributes = val;
2295   }
2296 
2297   bool operator == (const Hbase_getRowWithColumnsTs_args & rhs) const
2298   {
2299     if (!(tableName == rhs.tableName))
2300       return false;
2301     if (!(row == rhs.row))
2302       return false;
2303     if (!(columns == rhs.columns))
2304       return false;
2305     if (!(timestamp == rhs.timestamp))
2306       return false;
2307     if (!(attributes == rhs.attributes))
2308       return false;
2309     return true;
2310   }
2311   bool operator != (const Hbase_getRowWithColumnsTs_args &rhs) const {
2312     return !(*this == rhs);
2313   }
2314 
2315   bool operator < (const Hbase_getRowWithColumnsTs_args & ) const;
2316 
2317   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2318   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2319 
2320 };
2321 
2322 
2323 class Hbase_getRowWithColumnsTs_pargs {
2324  public:
2325 
2326 
~Hbase_getRowWithColumnsTs_pargs()2327   virtual ~Hbase_getRowWithColumnsTs_pargs() throw() {}
2328 
2329   const Text* tableName;
2330   const Text* row;
2331   const std::vector<Text> * columns;
2332   const int64_t* timestamp;
2333   const std::map<Text, Text> * attributes;
2334 
2335   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2336 
2337 };
2338 
2339 typedef struct _Hbase_getRowWithColumnsTs_result__isset {
_Hbase_getRowWithColumnsTs_result__isset_Hbase_getRowWithColumnsTs_result__isset2340   _Hbase_getRowWithColumnsTs_result__isset() : success(false), io(false) {}
2341   bool success;
2342   bool io;
2343 } _Hbase_getRowWithColumnsTs_result__isset;
2344 
2345 class Hbase_getRowWithColumnsTs_result {
2346  public:
2347 
Hbase_getRowWithColumnsTs_result()2348   Hbase_getRowWithColumnsTs_result() {
2349   }
2350 
~Hbase_getRowWithColumnsTs_result()2351   virtual ~Hbase_getRowWithColumnsTs_result() throw() {}
2352 
2353   std::vector<TRowResult>  success;
2354   IOError io;
2355 
2356   _Hbase_getRowWithColumnsTs_result__isset __isset;
2357 
__set_success(const std::vector<TRowResult> & val)2358   void __set_success(const std::vector<TRowResult> & val) {
2359     success = val;
2360   }
2361 
__set_io(const IOError & val)2362   void __set_io(const IOError& val) {
2363     io = val;
2364   }
2365 
2366   bool operator == (const Hbase_getRowWithColumnsTs_result & rhs) const
2367   {
2368     if (!(success == rhs.success))
2369       return false;
2370     if (!(io == rhs.io))
2371       return false;
2372     return true;
2373   }
2374   bool operator != (const Hbase_getRowWithColumnsTs_result &rhs) const {
2375     return !(*this == rhs);
2376   }
2377 
2378   bool operator < (const Hbase_getRowWithColumnsTs_result & ) const;
2379 
2380   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2381   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2382 
2383 };
2384 
2385 typedef struct _Hbase_getRowWithColumnsTs_presult__isset {
_Hbase_getRowWithColumnsTs_presult__isset_Hbase_getRowWithColumnsTs_presult__isset2386   _Hbase_getRowWithColumnsTs_presult__isset() : success(false), io(false) {}
2387   bool success;
2388   bool io;
2389 } _Hbase_getRowWithColumnsTs_presult__isset;
2390 
2391 class Hbase_getRowWithColumnsTs_presult {
2392  public:
2393 
2394 
~Hbase_getRowWithColumnsTs_presult()2395   virtual ~Hbase_getRowWithColumnsTs_presult() throw() {}
2396 
2397   std::vector<TRowResult> * success;
2398   IOError io;
2399 
2400   _Hbase_getRowWithColumnsTs_presult__isset __isset;
2401 
2402   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2403 
2404 };
2405 
2406 typedef struct _Hbase_getRows_args__isset {
_Hbase_getRows_args__isset_Hbase_getRows_args__isset2407   _Hbase_getRows_args__isset() : tableName(false), rows(false), attributes(false) {}
2408   bool tableName;
2409   bool rows;
2410   bool attributes;
2411 } _Hbase_getRows_args__isset;
2412 
2413 class Hbase_getRows_args {
2414  public:
2415 
Hbase_getRows_args()2416   Hbase_getRows_args() : tableName() {
2417   }
2418 
~Hbase_getRows_args()2419   virtual ~Hbase_getRows_args() throw() {}
2420 
2421   Text tableName;
2422   std::vector<Text>  rows;
2423   std::map<Text, Text>  attributes;
2424 
2425   _Hbase_getRows_args__isset __isset;
2426 
__set_tableName(const Text & val)2427   void __set_tableName(const Text& val) {
2428     tableName = val;
2429   }
2430 
__set_rows(const std::vector<Text> & val)2431   void __set_rows(const std::vector<Text> & val) {
2432     rows = val;
2433   }
2434 
__set_attributes(const std::map<Text,Text> & val)2435   void __set_attributes(const std::map<Text, Text> & val) {
2436     attributes = val;
2437   }
2438 
2439   bool operator == (const Hbase_getRows_args & rhs) const
2440   {
2441     if (!(tableName == rhs.tableName))
2442       return false;
2443     if (!(rows == rhs.rows))
2444       return false;
2445     if (!(attributes == rhs.attributes))
2446       return false;
2447     return true;
2448   }
2449   bool operator != (const Hbase_getRows_args &rhs) const {
2450     return !(*this == rhs);
2451   }
2452 
2453   bool operator < (const Hbase_getRows_args & ) const;
2454 
2455   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2456   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2457 
2458 };
2459 
2460 
2461 class Hbase_getRows_pargs {
2462  public:
2463 
2464 
~Hbase_getRows_pargs()2465   virtual ~Hbase_getRows_pargs() throw() {}
2466 
2467   const Text* tableName;
2468   const std::vector<Text> * rows;
2469   const std::map<Text, Text> * attributes;
2470 
2471   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2472 
2473 };
2474 
2475 typedef struct _Hbase_getRows_result__isset {
_Hbase_getRows_result__isset_Hbase_getRows_result__isset2476   _Hbase_getRows_result__isset() : success(false), io(false) {}
2477   bool success;
2478   bool io;
2479 } _Hbase_getRows_result__isset;
2480 
2481 class Hbase_getRows_result {
2482  public:
2483 
Hbase_getRows_result()2484   Hbase_getRows_result() {
2485   }
2486 
~Hbase_getRows_result()2487   virtual ~Hbase_getRows_result() throw() {}
2488 
2489   std::vector<TRowResult>  success;
2490   IOError io;
2491 
2492   _Hbase_getRows_result__isset __isset;
2493 
__set_success(const std::vector<TRowResult> & val)2494   void __set_success(const std::vector<TRowResult> & val) {
2495     success = val;
2496   }
2497 
__set_io(const IOError & val)2498   void __set_io(const IOError& val) {
2499     io = val;
2500   }
2501 
2502   bool operator == (const Hbase_getRows_result & rhs) const
2503   {
2504     if (!(success == rhs.success))
2505       return false;
2506     if (!(io == rhs.io))
2507       return false;
2508     return true;
2509   }
2510   bool operator != (const Hbase_getRows_result &rhs) const {
2511     return !(*this == rhs);
2512   }
2513 
2514   bool operator < (const Hbase_getRows_result & ) const;
2515 
2516   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2517   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2518 
2519 };
2520 
2521 typedef struct _Hbase_getRows_presult__isset {
_Hbase_getRows_presult__isset_Hbase_getRows_presult__isset2522   _Hbase_getRows_presult__isset() : success(false), io(false) {}
2523   bool success;
2524   bool io;
2525 } _Hbase_getRows_presult__isset;
2526 
2527 class Hbase_getRows_presult {
2528  public:
2529 
2530 
~Hbase_getRows_presult()2531   virtual ~Hbase_getRows_presult() throw() {}
2532 
2533   std::vector<TRowResult> * success;
2534   IOError io;
2535 
2536   _Hbase_getRows_presult__isset __isset;
2537 
2538   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2539 
2540 };
2541 
2542 typedef struct _Hbase_getRowsWithColumns_args__isset {
_Hbase_getRowsWithColumns_args__isset_Hbase_getRowsWithColumns_args__isset2543   _Hbase_getRowsWithColumns_args__isset() : tableName(false), rows(false), columns(false), attributes(false) {}
2544   bool tableName;
2545   bool rows;
2546   bool columns;
2547   bool attributes;
2548 } _Hbase_getRowsWithColumns_args__isset;
2549 
2550 class Hbase_getRowsWithColumns_args {
2551  public:
2552 
Hbase_getRowsWithColumns_args()2553   Hbase_getRowsWithColumns_args() : tableName() {
2554   }
2555 
~Hbase_getRowsWithColumns_args()2556   virtual ~Hbase_getRowsWithColumns_args() throw() {}
2557 
2558   Text tableName;
2559   std::vector<Text>  rows;
2560   std::vector<Text>  columns;
2561   std::map<Text, Text>  attributes;
2562 
2563   _Hbase_getRowsWithColumns_args__isset __isset;
2564 
__set_tableName(const Text & val)2565   void __set_tableName(const Text& val) {
2566     tableName = val;
2567   }
2568 
__set_rows(const std::vector<Text> & val)2569   void __set_rows(const std::vector<Text> & val) {
2570     rows = val;
2571   }
2572 
__set_columns(const std::vector<Text> & val)2573   void __set_columns(const std::vector<Text> & val) {
2574     columns = val;
2575   }
2576 
__set_attributes(const std::map<Text,Text> & val)2577   void __set_attributes(const std::map<Text, Text> & val) {
2578     attributes = val;
2579   }
2580 
2581   bool operator == (const Hbase_getRowsWithColumns_args & rhs) const
2582   {
2583     if (!(tableName == rhs.tableName))
2584       return false;
2585     if (!(rows == rhs.rows))
2586       return false;
2587     if (!(columns == rhs.columns))
2588       return false;
2589     if (!(attributes == rhs.attributes))
2590       return false;
2591     return true;
2592   }
2593   bool operator != (const Hbase_getRowsWithColumns_args &rhs) const {
2594     return !(*this == rhs);
2595   }
2596 
2597   bool operator < (const Hbase_getRowsWithColumns_args & ) const;
2598 
2599   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2600   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2601 
2602 };
2603 
2604 
2605 class Hbase_getRowsWithColumns_pargs {
2606  public:
2607 
2608 
~Hbase_getRowsWithColumns_pargs()2609   virtual ~Hbase_getRowsWithColumns_pargs() throw() {}
2610 
2611   const Text* tableName;
2612   const std::vector<Text> * rows;
2613   const std::vector<Text> * columns;
2614   const std::map<Text, Text> * attributes;
2615 
2616   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2617 
2618 };
2619 
2620 typedef struct _Hbase_getRowsWithColumns_result__isset {
_Hbase_getRowsWithColumns_result__isset_Hbase_getRowsWithColumns_result__isset2621   _Hbase_getRowsWithColumns_result__isset() : success(false), io(false) {}
2622   bool success;
2623   bool io;
2624 } _Hbase_getRowsWithColumns_result__isset;
2625 
2626 class Hbase_getRowsWithColumns_result {
2627  public:
2628 
Hbase_getRowsWithColumns_result()2629   Hbase_getRowsWithColumns_result() {
2630   }
2631 
~Hbase_getRowsWithColumns_result()2632   virtual ~Hbase_getRowsWithColumns_result() throw() {}
2633 
2634   std::vector<TRowResult>  success;
2635   IOError io;
2636 
2637   _Hbase_getRowsWithColumns_result__isset __isset;
2638 
__set_success(const std::vector<TRowResult> & val)2639   void __set_success(const std::vector<TRowResult> & val) {
2640     success = val;
2641   }
2642 
__set_io(const IOError & val)2643   void __set_io(const IOError& val) {
2644     io = val;
2645   }
2646 
2647   bool operator == (const Hbase_getRowsWithColumns_result & rhs) const
2648   {
2649     if (!(success == rhs.success))
2650       return false;
2651     if (!(io == rhs.io))
2652       return false;
2653     return true;
2654   }
2655   bool operator != (const Hbase_getRowsWithColumns_result &rhs) const {
2656     return !(*this == rhs);
2657   }
2658 
2659   bool operator < (const Hbase_getRowsWithColumns_result & ) const;
2660 
2661   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2662   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2663 
2664 };
2665 
2666 typedef struct _Hbase_getRowsWithColumns_presult__isset {
_Hbase_getRowsWithColumns_presult__isset_Hbase_getRowsWithColumns_presult__isset2667   _Hbase_getRowsWithColumns_presult__isset() : success(false), io(false) {}
2668   bool success;
2669   bool io;
2670 } _Hbase_getRowsWithColumns_presult__isset;
2671 
2672 class Hbase_getRowsWithColumns_presult {
2673  public:
2674 
2675 
~Hbase_getRowsWithColumns_presult()2676   virtual ~Hbase_getRowsWithColumns_presult() throw() {}
2677 
2678   std::vector<TRowResult> * success;
2679   IOError io;
2680 
2681   _Hbase_getRowsWithColumns_presult__isset __isset;
2682 
2683   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2684 
2685 };
2686 
2687 typedef struct _Hbase_getRowsTs_args__isset {
_Hbase_getRowsTs_args__isset_Hbase_getRowsTs_args__isset2688   _Hbase_getRowsTs_args__isset() : tableName(false), rows(false), timestamp(false), attributes(false) {}
2689   bool tableName;
2690   bool rows;
2691   bool timestamp;
2692   bool attributes;
2693 } _Hbase_getRowsTs_args__isset;
2694 
2695 class Hbase_getRowsTs_args {
2696  public:
2697 
Hbase_getRowsTs_args()2698   Hbase_getRowsTs_args() : tableName(), timestamp(0) {
2699   }
2700 
~Hbase_getRowsTs_args()2701   virtual ~Hbase_getRowsTs_args() throw() {}
2702 
2703   Text tableName;
2704   std::vector<Text>  rows;
2705   int64_t timestamp;
2706   std::map<Text, Text>  attributes;
2707 
2708   _Hbase_getRowsTs_args__isset __isset;
2709 
__set_tableName(const Text & val)2710   void __set_tableName(const Text& val) {
2711     tableName = val;
2712   }
2713 
__set_rows(const std::vector<Text> & val)2714   void __set_rows(const std::vector<Text> & val) {
2715     rows = val;
2716   }
2717 
__set_timestamp(const int64_t val)2718   void __set_timestamp(const int64_t val) {
2719     timestamp = val;
2720   }
2721 
__set_attributes(const std::map<Text,Text> & val)2722   void __set_attributes(const std::map<Text, Text> & val) {
2723     attributes = val;
2724   }
2725 
2726   bool operator == (const Hbase_getRowsTs_args & rhs) const
2727   {
2728     if (!(tableName == rhs.tableName))
2729       return false;
2730     if (!(rows == rhs.rows))
2731       return false;
2732     if (!(timestamp == rhs.timestamp))
2733       return false;
2734     if (!(attributes == rhs.attributes))
2735       return false;
2736     return true;
2737   }
2738   bool operator != (const Hbase_getRowsTs_args &rhs) const {
2739     return !(*this == rhs);
2740   }
2741 
2742   bool operator < (const Hbase_getRowsTs_args & ) const;
2743 
2744   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2745   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2746 
2747 };
2748 
2749 
2750 class Hbase_getRowsTs_pargs {
2751  public:
2752 
2753 
~Hbase_getRowsTs_pargs()2754   virtual ~Hbase_getRowsTs_pargs() throw() {}
2755 
2756   const Text* tableName;
2757   const std::vector<Text> * rows;
2758   const int64_t* timestamp;
2759   const std::map<Text, Text> * attributes;
2760 
2761   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2762 
2763 };
2764 
2765 typedef struct _Hbase_getRowsTs_result__isset {
_Hbase_getRowsTs_result__isset_Hbase_getRowsTs_result__isset2766   _Hbase_getRowsTs_result__isset() : success(false), io(false) {}
2767   bool success;
2768   bool io;
2769 } _Hbase_getRowsTs_result__isset;
2770 
2771 class Hbase_getRowsTs_result {
2772  public:
2773 
Hbase_getRowsTs_result()2774   Hbase_getRowsTs_result() {
2775   }
2776 
~Hbase_getRowsTs_result()2777   virtual ~Hbase_getRowsTs_result() throw() {}
2778 
2779   std::vector<TRowResult>  success;
2780   IOError io;
2781 
2782   _Hbase_getRowsTs_result__isset __isset;
2783 
__set_success(const std::vector<TRowResult> & val)2784   void __set_success(const std::vector<TRowResult> & val) {
2785     success = val;
2786   }
2787 
__set_io(const IOError & val)2788   void __set_io(const IOError& val) {
2789     io = val;
2790   }
2791 
2792   bool operator == (const Hbase_getRowsTs_result & rhs) const
2793   {
2794     if (!(success == rhs.success))
2795       return false;
2796     if (!(io == rhs.io))
2797       return false;
2798     return true;
2799   }
2800   bool operator != (const Hbase_getRowsTs_result &rhs) const {
2801     return !(*this == rhs);
2802   }
2803 
2804   bool operator < (const Hbase_getRowsTs_result & ) const;
2805 
2806   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2807   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2808 
2809 };
2810 
2811 typedef struct _Hbase_getRowsTs_presult__isset {
_Hbase_getRowsTs_presult__isset_Hbase_getRowsTs_presult__isset2812   _Hbase_getRowsTs_presult__isset() : success(false), io(false) {}
2813   bool success;
2814   bool io;
2815 } _Hbase_getRowsTs_presult__isset;
2816 
2817 class Hbase_getRowsTs_presult {
2818  public:
2819 
2820 
~Hbase_getRowsTs_presult()2821   virtual ~Hbase_getRowsTs_presult() throw() {}
2822 
2823   std::vector<TRowResult> * success;
2824   IOError io;
2825 
2826   _Hbase_getRowsTs_presult__isset __isset;
2827 
2828   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2829 
2830 };
2831 
2832 typedef struct _Hbase_getRowsWithColumnsTs_args__isset {
_Hbase_getRowsWithColumnsTs_args__isset_Hbase_getRowsWithColumnsTs_args__isset2833   _Hbase_getRowsWithColumnsTs_args__isset() : tableName(false), rows(false), columns(false), timestamp(false), attributes(false) {}
2834   bool tableName;
2835   bool rows;
2836   bool columns;
2837   bool timestamp;
2838   bool attributes;
2839 } _Hbase_getRowsWithColumnsTs_args__isset;
2840 
2841 class Hbase_getRowsWithColumnsTs_args {
2842  public:
2843 
Hbase_getRowsWithColumnsTs_args()2844   Hbase_getRowsWithColumnsTs_args() : tableName(), timestamp(0) {
2845   }
2846 
~Hbase_getRowsWithColumnsTs_args()2847   virtual ~Hbase_getRowsWithColumnsTs_args() throw() {}
2848 
2849   Text tableName;
2850   std::vector<Text>  rows;
2851   std::vector<Text>  columns;
2852   int64_t timestamp;
2853   std::map<Text, Text>  attributes;
2854 
2855   _Hbase_getRowsWithColumnsTs_args__isset __isset;
2856 
__set_tableName(const Text & val)2857   void __set_tableName(const Text& val) {
2858     tableName = val;
2859   }
2860 
__set_rows(const std::vector<Text> & val)2861   void __set_rows(const std::vector<Text> & val) {
2862     rows = val;
2863   }
2864 
__set_columns(const std::vector<Text> & val)2865   void __set_columns(const std::vector<Text> & val) {
2866     columns = val;
2867   }
2868 
__set_timestamp(const int64_t val)2869   void __set_timestamp(const int64_t val) {
2870     timestamp = val;
2871   }
2872 
__set_attributes(const std::map<Text,Text> & val)2873   void __set_attributes(const std::map<Text, Text> & val) {
2874     attributes = val;
2875   }
2876 
2877   bool operator == (const Hbase_getRowsWithColumnsTs_args & rhs) const
2878   {
2879     if (!(tableName == rhs.tableName))
2880       return false;
2881     if (!(rows == rhs.rows))
2882       return false;
2883     if (!(columns == rhs.columns))
2884       return false;
2885     if (!(timestamp == rhs.timestamp))
2886       return false;
2887     if (!(attributes == rhs.attributes))
2888       return false;
2889     return true;
2890   }
2891   bool operator != (const Hbase_getRowsWithColumnsTs_args &rhs) const {
2892     return !(*this == rhs);
2893   }
2894 
2895   bool operator < (const Hbase_getRowsWithColumnsTs_args & ) const;
2896 
2897   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2898   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2899 
2900 };
2901 
2902 
2903 class Hbase_getRowsWithColumnsTs_pargs {
2904  public:
2905 
2906 
~Hbase_getRowsWithColumnsTs_pargs()2907   virtual ~Hbase_getRowsWithColumnsTs_pargs() throw() {}
2908 
2909   const Text* tableName;
2910   const std::vector<Text> * rows;
2911   const std::vector<Text> * columns;
2912   const int64_t* timestamp;
2913   const std::map<Text, Text> * attributes;
2914 
2915   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2916 
2917 };
2918 
2919 typedef struct _Hbase_getRowsWithColumnsTs_result__isset {
_Hbase_getRowsWithColumnsTs_result__isset_Hbase_getRowsWithColumnsTs_result__isset2920   _Hbase_getRowsWithColumnsTs_result__isset() : success(false), io(false) {}
2921   bool success;
2922   bool io;
2923 } _Hbase_getRowsWithColumnsTs_result__isset;
2924 
2925 class Hbase_getRowsWithColumnsTs_result {
2926  public:
2927 
Hbase_getRowsWithColumnsTs_result()2928   Hbase_getRowsWithColumnsTs_result() {
2929   }
2930 
~Hbase_getRowsWithColumnsTs_result()2931   virtual ~Hbase_getRowsWithColumnsTs_result() throw() {}
2932 
2933   std::vector<TRowResult>  success;
2934   IOError io;
2935 
2936   _Hbase_getRowsWithColumnsTs_result__isset __isset;
2937 
__set_success(const std::vector<TRowResult> & val)2938   void __set_success(const std::vector<TRowResult> & val) {
2939     success = val;
2940   }
2941 
__set_io(const IOError & val)2942   void __set_io(const IOError& val) {
2943     io = val;
2944   }
2945 
2946   bool operator == (const Hbase_getRowsWithColumnsTs_result & rhs) const
2947   {
2948     if (!(success == rhs.success))
2949       return false;
2950     if (!(io == rhs.io))
2951       return false;
2952     return true;
2953   }
2954   bool operator != (const Hbase_getRowsWithColumnsTs_result &rhs) const {
2955     return !(*this == rhs);
2956   }
2957 
2958   bool operator < (const Hbase_getRowsWithColumnsTs_result & ) const;
2959 
2960   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2961   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
2962 
2963 };
2964 
2965 typedef struct _Hbase_getRowsWithColumnsTs_presult__isset {
_Hbase_getRowsWithColumnsTs_presult__isset_Hbase_getRowsWithColumnsTs_presult__isset2966   _Hbase_getRowsWithColumnsTs_presult__isset() : success(false), io(false) {}
2967   bool success;
2968   bool io;
2969 } _Hbase_getRowsWithColumnsTs_presult__isset;
2970 
2971 class Hbase_getRowsWithColumnsTs_presult {
2972  public:
2973 
2974 
~Hbase_getRowsWithColumnsTs_presult()2975   virtual ~Hbase_getRowsWithColumnsTs_presult() throw() {}
2976 
2977   std::vector<TRowResult> * success;
2978   IOError io;
2979 
2980   _Hbase_getRowsWithColumnsTs_presult__isset __isset;
2981 
2982   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
2983 
2984 };
2985 
2986 typedef struct _Hbase_mutateRow_args__isset {
_Hbase_mutateRow_args__isset_Hbase_mutateRow_args__isset2987   _Hbase_mutateRow_args__isset() : tableName(false), row(false), mutations(false), attributes(false) {}
2988   bool tableName;
2989   bool row;
2990   bool mutations;
2991   bool attributes;
2992 } _Hbase_mutateRow_args__isset;
2993 
2994 class Hbase_mutateRow_args {
2995  public:
2996 
Hbase_mutateRow_args()2997   Hbase_mutateRow_args() : tableName(), row() {
2998   }
2999 
~Hbase_mutateRow_args()3000   virtual ~Hbase_mutateRow_args() throw() {}
3001 
3002   Text tableName;
3003   Text row;
3004   std::vector<Mutation>  mutations;
3005   std::map<Text, Text>  attributes;
3006 
3007   _Hbase_mutateRow_args__isset __isset;
3008 
__set_tableName(const Text & val)3009   void __set_tableName(const Text& val) {
3010     tableName = val;
3011   }
3012 
__set_row(const Text & val)3013   void __set_row(const Text& val) {
3014     row = val;
3015   }
3016 
__set_mutations(const std::vector<Mutation> & val)3017   void __set_mutations(const std::vector<Mutation> & val) {
3018     mutations = val;
3019   }
3020 
__set_attributes(const std::map<Text,Text> & val)3021   void __set_attributes(const std::map<Text, Text> & val) {
3022     attributes = val;
3023   }
3024 
3025   bool operator == (const Hbase_mutateRow_args & rhs) const
3026   {
3027     if (!(tableName == rhs.tableName))
3028       return false;
3029     if (!(row == rhs.row))
3030       return false;
3031     if (!(mutations == rhs.mutations))
3032       return false;
3033     if (!(attributes == rhs.attributes))
3034       return false;
3035     return true;
3036   }
3037   bool operator != (const Hbase_mutateRow_args &rhs) const {
3038     return !(*this == rhs);
3039   }
3040 
3041   bool operator < (const Hbase_mutateRow_args & ) const;
3042 
3043   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3044   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3045 
3046 };
3047 
3048 
3049 class Hbase_mutateRow_pargs {
3050  public:
3051 
3052 
~Hbase_mutateRow_pargs()3053   virtual ~Hbase_mutateRow_pargs() throw() {}
3054 
3055   const Text* tableName;
3056   const Text* row;
3057   const std::vector<Mutation> * mutations;
3058   const std::map<Text, Text> * attributes;
3059 
3060   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3061 
3062 };
3063 
3064 typedef struct _Hbase_mutateRow_result__isset {
_Hbase_mutateRow_result__isset_Hbase_mutateRow_result__isset3065   _Hbase_mutateRow_result__isset() : io(false), ia(false) {}
3066   bool io;
3067   bool ia;
3068 } _Hbase_mutateRow_result__isset;
3069 
3070 class Hbase_mutateRow_result {
3071  public:
3072 
Hbase_mutateRow_result()3073   Hbase_mutateRow_result() {
3074   }
3075 
~Hbase_mutateRow_result()3076   virtual ~Hbase_mutateRow_result() throw() {}
3077 
3078   IOError io;
3079   IllegalArgument ia;
3080 
3081   _Hbase_mutateRow_result__isset __isset;
3082 
__set_io(const IOError & val)3083   void __set_io(const IOError& val) {
3084     io = val;
3085   }
3086 
__set_ia(const IllegalArgument & val)3087   void __set_ia(const IllegalArgument& val) {
3088     ia = val;
3089   }
3090 
3091   bool operator == (const Hbase_mutateRow_result & rhs) const
3092   {
3093     if (!(io == rhs.io))
3094       return false;
3095     if (!(ia == rhs.ia))
3096       return false;
3097     return true;
3098   }
3099   bool operator != (const Hbase_mutateRow_result &rhs) const {
3100     return !(*this == rhs);
3101   }
3102 
3103   bool operator < (const Hbase_mutateRow_result & ) const;
3104 
3105   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3106   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3107 
3108 };
3109 
3110 typedef struct _Hbase_mutateRow_presult__isset {
_Hbase_mutateRow_presult__isset_Hbase_mutateRow_presult__isset3111   _Hbase_mutateRow_presult__isset() : io(false), ia(false) {}
3112   bool io;
3113   bool ia;
3114 } _Hbase_mutateRow_presult__isset;
3115 
3116 class Hbase_mutateRow_presult {
3117  public:
3118 
3119 
~Hbase_mutateRow_presult()3120   virtual ~Hbase_mutateRow_presult() throw() {}
3121 
3122   IOError io;
3123   IllegalArgument ia;
3124 
3125   _Hbase_mutateRow_presult__isset __isset;
3126 
3127   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3128 
3129 };
3130 
3131 typedef struct _Hbase_mutateRowTs_args__isset {
_Hbase_mutateRowTs_args__isset_Hbase_mutateRowTs_args__isset3132   _Hbase_mutateRowTs_args__isset() : tableName(false), row(false), mutations(false), timestamp(false), attributes(false) {}
3133   bool tableName;
3134   bool row;
3135   bool mutations;
3136   bool timestamp;
3137   bool attributes;
3138 } _Hbase_mutateRowTs_args__isset;
3139 
3140 class Hbase_mutateRowTs_args {
3141  public:
3142 
Hbase_mutateRowTs_args()3143   Hbase_mutateRowTs_args() : tableName(), row(), timestamp(0) {
3144   }
3145 
~Hbase_mutateRowTs_args()3146   virtual ~Hbase_mutateRowTs_args() throw() {}
3147 
3148   Text tableName;
3149   Text row;
3150   std::vector<Mutation>  mutations;
3151   int64_t timestamp;
3152   std::map<Text, Text>  attributes;
3153 
3154   _Hbase_mutateRowTs_args__isset __isset;
3155 
__set_tableName(const Text & val)3156   void __set_tableName(const Text& val) {
3157     tableName = val;
3158   }
3159 
__set_row(const Text & val)3160   void __set_row(const Text& val) {
3161     row = val;
3162   }
3163 
__set_mutations(const std::vector<Mutation> & val)3164   void __set_mutations(const std::vector<Mutation> & val) {
3165     mutations = val;
3166   }
3167 
__set_timestamp(const int64_t val)3168   void __set_timestamp(const int64_t val) {
3169     timestamp = val;
3170   }
3171 
__set_attributes(const std::map<Text,Text> & val)3172   void __set_attributes(const std::map<Text, Text> & val) {
3173     attributes = val;
3174   }
3175 
3176   bool operator == (const Hbase_mutateRowTs_args & rhs) const
3177   {
3178     if (!(tableName == rhs.tableName))
3179       return false;
3180     if (!(row == rhs.row))
3181       return false;
3182     if (!(mutations == rhs.mutations))
3183       return false;
3184     if (!(timestamp == rhs.timestamp))
3185       return false;
3186     if (!(attributes == rhs.attributes))
3187       return false;
3188     return true;
3189   }
3190   bool operator != (const Hbase_mutateRowTs_args &rhs) const {
3191     return !(*this == rhs);
3192   }
3193 
3194   bool operator < (const Hbase_mutateRowTs_args & ) const;
3195 
3196   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3197   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3198 
3199 };
3200 
3201 
3202 class Hbase_mutateRowTs_pargs {
3203  public:
3204 
3205 
~Hbase_mutateRowTs_pargs()3206   virtual ~Hbase_mutateRowTs_pargs() throw() {}
3207 
3208   const Text* tableName;
3209   const Text* row;
3210   const std::vector<Mutation> * mutations;
3211   const int64_t* timestamp;
3212   const std::map<Text, Text> * attributes;
3213 
3214   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3215 
3216 };
3217 
3218 typedef struct _Hbase_mutateRowTs_result__isset {
_Hbase_mutateRowTs_result__isset_Hbase_mutateRowTs_result__isset3219   _Hbase_mutateRowTs_result__isset() : io(false), ia(false) {}
3220   bool io;
3221   bool ia;
3222 } _Hbase_mutateRowTs_result__isset;
3223 
3224 class Hbase_mutateRowTs_result {
3225  public:
3226 
Hbase_mutateRowTs_result()3227   Hbase_mutateRowTs_result() {
3228   }
3229 
~Hbase_mutateRowTs_result()3230   virtual ~Hbase_mutateRowTs_result() throw() {}
3231 
3232   IOError io;
3233   IllegalArgument ia;
3234 
3235   _Hbase_mutateRowTs_result__isset __isset;
3236 
__set_io(const IOError & val)3237   void __set_io(const IOError& val) {
3238     io = val;
3239   }
3240 
__set_ia(const IllegalArgument & val)3241   void __set_ia(const IllegalArgument& val) {
3242     ia = val;
3243   }
3244 
3245   bool operator == (const Hbase_mutateRowTs_result & rhs) const
3246   {
3247     if (!(io == rhs.io))
3248       return false;
3249     if (!(ia == rhs.ia))
3250       return false;
3251     return true;
3252   }
3253   bool operator != (const Hbase_mutateRowTs_result &rhs) const {
3254     return !(*this == rhs);
3255   }
3256 
3257   bool operator < (const Hbase_mutateRowTs_result & ) const;
3258 
3259   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3260   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3261 
3262 };
3263 
3264 typedef struct _Hbase_mutateRowTs_presult__isset {
_Hbase_mutateRowTs_presult__isset_Hbase_mutateRowTs_presult__isset3265   _Hbase_mutateRowTs_presult__isset() : io(false), ia(false) {}
3266   bool io;
3267   bool ia;
3268 } _Hbase_mutateRowTs_presult__isset;
3269 
3270 class Hbase_mutateRowTs_presult {
3271  public:
3272 
3273 
~Hbase_mutateRowTs_presult()3274   virtual ~Hbase_mutateRowTs_presult() throw() {}
3275 
3276   IOError io;
3277   IllegalArgument ia;
3278 
3279   _Hbase_mutateRowTs_presult__isset __isset;
3280 
3281   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3282 
3283 };
3284 
3285 typedef struct _Hbase_mutateRows_args__isset {
_Hbase_mutateRows_args__isset_Hbase_mutateRows_args__isset3286   _Hbase_mutateRows_args__isset() : tableName(false), rowBatches(false), attributes(false) {}
3287   bool tableName;
3288   bool rowBatches;
3289   bool attributes;
3290 } _Hbase_mutateRows_args__isset;
3291 
3292 class Hbase_mutateRows_args {
3293  public:
3294 
Hbase_mutateRows_args()3295   Hbase_mutateRows_args() : tableName() {
3296   }
3297 
~Hbase_mutateRows_args()3298   virtual ~Hbase_mutateRows_args() throw() {}
3299 
3300   Text tableName;
3301   std::vector<BatchMutation>  rowBatches;
3302   std::map<Text, Text>  attributes;
3303 
3304   _Hbase_mutateRows_args__isset __isset;
3305 
__set_tableName(const Text & val)3306   void __set_tableName(const Text& val) {
3307     tableName = val;
3308   }
3309 
__set_rowBatches(const std::vector<BatchMutation> & val)3310   void __set_rowBatches(const std::vector<BatchMutation> & val) {
3311     rowBatches = val;
3312   }
3313 
__set_attributes(const std::map<Text,Text> & val)3314   void __set_attributes(const std::map<Text, Text> & val) {
3315     attributes = val;
3316   }
3317 
3318   bool operator == (const Hbase_mutateRows_args & rhs) const
3319   {
3320     if (!(tableName == rhs.tableName))
3321       return false;
3322     if (!(rowBatches == rhs.rowBatches))
3323       return false;
3324     if (!(attributes == rhs.attributes))
3325       return false;
3326     return true;
3327   }
3328   bool operator != (const Hbase_mutateRows_args &rhs) const {
3329     return !(*this == rhs);
3330   }
3331 
3332   bool operator < (const Hbase_mutateRows_args & ) const;
3333 
3334   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3335   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3336 
3337 };
3338 
3339 
3340 class Hbase_mutateRows_pargs {
3341  public:
3342 
3343 
~Hbase_mutateRows_pargs()3344   virtual ~Hbase_mutateRows_pargs() throw() {}
3345 
3346   const Text* tableName;
3347   const std::vector<BatchMutation> * rowBatches;
3348   const std::map<Text, Text> * attributes;
3349 
3350   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3351 
3352 };
3353 
3354 typedef struct _Hbase_mutateRows_result__isset {
_Hbase_mutateRows_result__isset_Hbase_mutateRows_result__isset3355   _Hbase_mutateRows_result__isset() : io(false), ia(false) {}
3356   bool io;
3357   bool ia;
3358 } _Hbase_mutateRows_result__isset;
3359 
3360 class Hbase_mutateRows_result {
3361  public:
3362 
Hbase_mutateRows_result()3363   Hbase_mutateRows_result() {
3364   }
3365 
~Hbase_mutateRows_result()3366   virtual ~Hbase_mutateRows_result() throw() {}
3367 
3368   IOError io;
3369   IllegalArgument ia;
3370 
3371   _Hbase_mutateRows_result__isset __isset;
3372 
__set_io(const IOError & val)3373   void __set_io(const IOError& val) {
3374     io = val;
3375   }
3376 
__set_ia(const IllegalArgument & val)3377   void __set_ia(const IllegalArgument& val) {
3378     ia = val;
3379   }
3380 
3381   bool operator == (const Hbase_mutateRows_result & rhs) const
3382   {
3383     if (!(io == rhs.io))
3384       return false;
3385     if (!(ia == rhs.ia))
3386       return false;
3387     return true;
3388   }
3389   bool operator != (const Hbase_mutateRows_result &rhs) const {
3390     return !(*this == rhs);
3391   }
3392 
3393   bool operator < (const Hbase_mutateRows_result & ) const;
3394 
3395   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3396   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3397 
3398 };
3399 
3400 typedef struct _Hbase_mutateRows_presult__isset {
_Hbase_mutateRows_presult__isset_Hbase_mutateRows_presult__isset3401   _Hbase_mutateRows_presult__isset() : io(false), ia(false) {}
3402   bool io;
3403   bool ia;
3404 } _Hbase_mutateRows_presult__isset;
3405 
3406 class Hbase_mutateRows_presult {
3407  public:
3408 
3409 
~Hbase_mutateRows_presult()3410   virtual ~Hbase_mutateRows_presult() throw() {}
3411 
3412   IOError io;
3413   IllegalArgument ia;
3414 
3415   _Hbase_mutateRows_presult__isset __isset;
3416 
3417   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3418 
3419 };
3420 
3421 typedef struct _Hbase_mutateRowsTs_args__isset {
_Hbase_mutateRowsTs_args__isset_Hbase_mutateRowsTs_args__isset3422   _Hbase_mutateRowsTs_args__isset() : tableName(false), rowBatches(false), timestamp(false), attributes(false) {}
3423   bool tableName;
3424   bool rowBatches;
3425   bool timestamp;
3426   bool attributes;
3427 } _Hbase_mutateRowsTs_args__isset;
3428 
3429 class Hbase_mutateRowsTs_args {
3430  public:
3431 
Hbase_mutateRowsTs_args()3432   Hbase_mutateRowsTs_args() : tableName(), timestamp(0) {
3433   }
3434 
~Hbase_mutateRowsTs_args()3435   virtual ~Hbase_mutateRowsTs_args() throw() {}
3436 
3437   Text tableName;
3438   std::vector<BatchMutation>  rowBatches;
3439   int64_t timestamp;
3440   std::map<Text, Text>  attributes;
3441 
3442   _Hbase_mutateRowsTs_args__isset __isset;
3443 
__set_tableName(const Text & val)3444   void __set_tableName(const Text& val) {
3445     tableName = val;
3446   }
3447 
__set_rowBatches(const std::vector<BatchMutation> & val)3448   void __set_rowBatches(const std::vector<BatchMutation> & val) {
3449     rowBatches = val;
3450   }
3451 
__set_timestamp(const int64_t val)3452   void __set_timestamp(const int64_t val) {
3453     timestamp = val;
3454   }
3455 
__set_attributes(const std::map<Text,Text> & val)3456   void __set_attributes(const std::map<Text, Text> & val) {
3457     attributes = val;
3458   }
3459 
3460   bool operator == (const Hbase_mutateRowsTs_args & rhs) const
3461   {
3462     if (!(tableName == rhs.tableName))
3463       return false;
3464     if (!(rowBatches == rhs.rowBatches))
3465       return false;
3466     if (!(timestamp == rhs.timestamp))
3467       return false;
3468     if (!(attributes == rhs.attributes))
3469       return false;
3470     return true;
3471   }
3472   bool operator != (const Hbase_mutateRowsTs_args &rhs) const {
3473     return !(*this == rhs);
3474   }
3475 
3476   bool operator < (const Hbase_mutateRowsTs_args & ) const;
3477 
3478   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3479   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3480 
3481 };
3482 
3483 
3484 class Hbase_mutateRowsTs_pargs {
3485  public:
3486 
3487 
~Hbase_mutateRowsTs_pargs()3488   virtual ~Hbase_mutateRowsTs_pargs() throw() {}
3489 
3490   const Text* tableName;
3491   const std::vector<BatchMutation> * rowBatches;
3492   const int64_t* timestamp;
3493   const std::map<Text, Text> * attributes;
3494 
3495   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3496 
3497 };
3498 
3499 typedef struct _Hbase_mutateRowsTs_result__isset {
_Hbase_mutateRowsTs_result__isset_Hbase_mutateRowsTs_result__isset3500   _Hbase_mutateRowsTs_result__isset() : io(false), ia(false) {}
3501   bool io;
3502   bool ia;
3503 } _Hbase_mutateRowsTs_result__isset;
3504 
3505 class Hbase_mutateRowsTs_result {
3506  public:
3507 
Hbase_mutateRowsTs_result()3508   Hbase_mutateRowsTs_result() {
3509   }
3510 
~Hbase_mutateRowsTs_result()3511   virtual ~Hbase_mutateRowsTs_result() throw() {}
3512 
3513   IOError io;
3514   IllegalArgument ia;
3515 
3516   _Hbase_mutateRowsTs_result__isset __isset;
3517 
__set_io(const IOError & val)3518   void __set_io(const IOError& val) {
3519     io = val;
3520   }
3521 
__set_ia(const IllegalArgument & val)3522   void __set_ia(const IllegalArgument& val) {
3523     ia = val;
3524   }
3525 
3526   bool operator == (const Hbase_mutateRowsTs_result & rhs) const
3527   {
3528     if (!(io == rhs.io))
3529       return false;
3530     if (!(ia == rhs.ia))
3531       return false;
3532     return true;
3533   }
3534   bool operator != (const Hbase_mutateRowsTs_result &rhs) const {
3535     return !(*this == rhs);
3536   }
3537 
3538   bool operator < (const Hbase_mutateRowsTs_result & ) const;
3539 
3540   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3541   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3542 
3543 };
3544 
3545 typedef struct _Hbase_mutateRowsTs_presult__isset {
_Hbase_mutateRowsTs_presult__isset_Hbase_mutateRowsTs_presult__isset3546   _Hbase_mutateRowsTs_presult__isset() : io(false), ia(false) {}
3547   bool io;
3548   bool ia;
3549 } _Hbase_mutateRowsTs_presult__isset;
3550 
3551 class Hbase_mutateRowsTs_presult {
3552  public:
3553 
3554 
~Hbase_mutateRowsTs_presult()3555   virtual ~Hbase_mutateRowsTs_presult() throw() {}
3556 
3557   IOError io;
3558   IllegalArgument ia;
3559 
3560   _Hbase_mutateRowsTs_presult__isset __isset;
3561 
3562   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3563 
3564 };
3565 
3566 typedef struct _Hbase_atomicIncrement_args__isset {
_Hbase_atomicIncrement_args__isset_Hbase_atomicIncrement_args__isset3567   _Hbase_atomicIncrement_args__isset() : tableName(false), row(false), column(false), value(false) {}
3568   bool tableName;
3569   bool row;
3570   bool column;
3571   bool value;
3572 } _Hbase_atomicIncrement_args__isset;
3573 
3574 class Hbase_atomicIncrement_args {
3575  public:
3576 
Hbase_atomicIncrement_args()3577   Hbase_atomicIncrement_args() : tableName(), row(), column(), value(0) {
3578   }
3579 
~Hbase_atomicIncrement_args()3580   virtual ~Hbase_atomicIncrement_args() throw() {}
3581 
3582   Text tableName;
3583   Text row;
3584   Text column;
3585   int64_t value;
3586 
3587   _Hbase_atomicIncrement_args__isset __isset;
3588 
__set_tableName(const Text & val)3589   void __set_tableName(const Text& val) {
3590     tableName = val;
3591   }
3592 
__set_row(const Text & val)3593   void __set_row(const Text& val) {
3594     row = val;
3595   }
3596 
__set_column(const Text & val)3597   void __set_column(const Text& val) {
3598     column = val;
3599   }
3600 
__set_value(const int64_t val)3601   void __set_value(const int64_t val) {
3602     value = val;
3603   }
3604 
3605   bool operator == (const Hbase_atomicIncrement_args & rhs) const
3606   {
3607     if (!(tableName == rhs.tableName))
3608       return false;
3609     if (!(row == rhs.row))
3610       return false;
3611     if (!(column == rhs.column))
3612       return false;
3613     if (!(value == rhs.value))
3614       return false;
3615     return true;
3616   }
3617   bool operator != (const Hbase_atomicIncrement_args &rhs) const {
3618     return !(*this == rhs);
3619   }
3620 
3621   bool operator < (const Hbase_atomicIncrement_args & ) const;
3622 
3623   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3624   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3625 
3626 };
3627 
3628 
3629 class Hbase_atomicIncrement_pargs {
3630  public:
3631 
3632 
~Hbase_atomicIncrement_pargs()3633   virtual ~Hbase_atomicIncrement_pargs() throw() {}
3634 
3635   const Text* tableName;
3636   const Text* row;
3637   const Text* column;
3638   const int64_t* value;
3639 
3640   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3641 
3642 };
3643 
3644 typedef struct _Hbase_atomicIncrement_result__isset {
_Hbase_atomicIncrement_result__isset_Hbase_atomicIncrement_result__isset3645   _Hbase_atomicIncrement_result__isset() : success(false), io(false), ia(false) {}
3646   bool success;
3647   bool io;
3648   bool ia;
3649 } _Hbase_atomicIncrement_result__isset;
3650 
3651 class Hbase_atomicIncrement_result {
3652  public:
3653 
Hbase_atomicIncrement_result()3654   Hbase_atomicIncrement_result() : success(0) {
3655   }
3656 
~Hbase_atomicIncrement_result()3657   virtual ~Hbase_atomicIncrement_result() throw() {}
3658 
3659   int64_t success;
3660   IOError io;
3661   IllegalArgument ia;
3662 
3663   _Hbase_atomicIncrement_result__isset __isset;
3664 
__set_success(const int64_t val)3665   void __set_success(const int64_t val) {
3666     success = val;
3667   }
3668 
__set_io(const IOError & val)3669   void __set_io(const IOError& val) {
3670     io = val;
3671   }
3672 
__set_ia(const IllegalArgument & val)3673   void __set_ia(const IllegalArgument& val) {
3674     ia = val;
3675   }
3676 
3677   bool operator == (const Hbase_atomicIncrement_result & rhs) const
3678   {
3679     if (!(success == rhs.success))
3680       return false;
3681     if (!(io == rhs.io))
3682       return false;
3683     if (!(ia == rhs.ia))
3684       return false;
3685     return true;
3686   }
3687   bool operator != (const Hbase_atomicIncrement_result &rhs) const {
3688     return !(*this == rhs);
3689   }
3690 
3691   bool operator < (const Hbase_atomicIncrement_result & ) const;
3692 
3693   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3694   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3695 
3696 };
3697 
3698 typedef struct _Hbase_atomicIncrement_presult__isset {
_Hbase_atomicIncrement_presult__isset_Hbase_atomicIncrement_presult__isset3699   _Hbase_atomicIncrement_presult__isset() : success(false), io(false), ia(false) {}
3700   bool success;
3701   bool io;
3702   bool ia;
3703 } _Hbase_atomicIncrement_presult__isset;
3704 
3705 class Hbase_atomicIncrement_presult {
3706  public:
3707 
3708 
~Hbase_atomicIncrement_presult()3709   virtual ~Hbase_atomicIncrement_presult() throw() {}
3710 
3711   int64_t* success;
3712   IOError io;
3713   IllegalArgument ia;
3714 
3715   _Hbase_atomicIncrement_presult__isset __isset;
3716 
3717   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3718 
3719 };
3720 
3721 typedef struct _Hbase_deleteAll_args__isset {
_Hbase_deleteAll_args__isset_Hbase_deleteAll_args__isset3722   _Hbase_deleteAll_args__isset() : tableName(false), row(false), column(false), attributes(false) {}
3723   bool tableName;
3724   bool row;
3725   bool column;
3726   bool attributes;
3727 } _Hbase_deleteAll_args__isset;
3728 
3729 class Hbase_deleteAll_args {
3730  public:
3731 
Hbase_deleteAll_args()3732   Hbase_deleteAll_args() : tableName(), row(), column() {
3733   }
3734 
~Hbase_deleteAll_args()3735   virtual ~Hbase_deleteAll_args() throw() {}
3736 
3737   Text tableName;
3738   Text row;
3739   Text column;
3740   std::map<Text, Text>  attributes;
3741 
3742   _Hbase_deleteAll_args__isset __isset;
3743 
__set_tableName(const Text & val)3744   void __set_tableName(const Text& val) {
3745     tableName = val;
3746   }
3747 
__set_row(const Text & val)3748   void __set_row(const Text& val) {
3749     row = val;
3750   }
3751 
__set_column(const Text & val)3752   void __set_column(const Text& val) {
3753     column = val;
3754   }
3755 
__set_attributes(const std::map<Text,Text> & val)3756   void __set_attributes(const std::map<Text, Text> & val) {
3757     attributes = val;
3758   }
3759 
3760   bool operator == (const Hbase_deleteAll_args & rhs) const
3761   {
3762     if (!(tableName == rhs.tableName))
3763       return false;
3764     if (!(row == rhs.row))
3765       return false;
3766     if (!(column == rhs.column))
3767       return false;
3768     if (!(attributes == rhs.attributes))
3769       return false;
3770     return true;
3771   }
3772   bool operator != (const Hbase_deleteAll_args &rhs) const {
3773     return !(*this == rhs);
3774   }
3775 
3776   bool operator < (const Hbase_deleteAll_args & ) const;
3777 
3778   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3779   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3780 
3781 };
3782 
3783 
3784 class Hbase_deleteAll_pargs {
3785  public:
3786 
3787 
~Hbase_deleteAll_pargs()3788   virtual ~Hbase_deleteAll_pargs() throw() {}
3789 
3790   const Text* tableName;
3791   const Text* row;
3792   const Text* column;
3793   const std::map<Text, Text> * attributes;
3794 
3795   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3796 
3797 };
3798 
3799 typedef struct _Hbase_deleteAll_result__isset {
_Hbase_deleteAll_result__isset_Hbase_deleteAll_result__isset3800   _Hbase_deleteAll_result__isset() : io(false) {}
3801   bool io;
3802 } _Hbase_deleteAll_result__isset;
3803 
3804 class Hbase_deleteAll_result {
3805  public:
3806 
Hbase_deleteAll_result()3807   Hbase_deleteAll_result() {
3808   }
3809 
~Hbase_deleteAll_result()3810   virtual ~Hbase_deleteAll_result() throw() {}
3811 
3812   IOError io;
3813 
3814   _Hbase_deleteAll_result__isset __isset;
3815 
__set_io(const IOError & val)3816   void __set_io(const IOError& val) {
3817     io = val;
3818   }
3819 
3820   bool operator == (const Hbase_deleteAll_result & rhs) const
3821   {
3822     if (!(io == rhs.io))
3823       return false;
3824     return true;
3825   }
3826   bool operator != (const Hbase_deleteAll_result &rhs) const {
3827     return !(*this == rhs);
3828   }
3829 
3830   bool operator < (const Hbase_deleteAll_result & ) const;
3831 
3832   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3833   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3834 
3835 };
3836 
3837 typedef struct _Hbase_deleteAll_presult__isset {
_Hbase_deleteAll_presult__isset_Hbase_deleteAll_presult__isset3838   _Hbase_deleteAll_presult__isset() : io(false) {}
3839   bool io;
3840 } _Hbase_deleteAll_presult__isset;
3841 
3842 class Hbase_deleteAll_presult {
3843  public:
3844 
3845 
~Hbase_deleteAll_presult()3846   virtual ~Hbase_deleteAll_presult() throw() {}
3847 
3848   IOError io;
3849 
3850   _Hbase_deleteAll_presult__isset __isset;
3851 
3852   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3853 
3854 };
3855 
3856 typedef struct _Hbase_deleteAllTs_args__isset {
_Hbase_deleteAllTs_args__isset_Hbase_deleteAllTs_args__isset3857   _Hbase_deleteAllTs_args__isset() : tableName(false), row(false), column(false), timestamp(false), attributes(false) {}
3858   bool tableName;
3859   bool row;
3860   bool column;
3861   bool timestamp;
3862   bool attributes;
3863 } _Hbase_deleteAllTs_args__isset;
3864 
3865 class Hbase_deleteAllTs_args {
3866  public:
3867 
Hbase_deleteAllTs_args()3868   Hbase_deleteAllTs_args() : tableName(), row(), column(), timestamp(0) {
3869   }
3870 
~Hbase_deleteAllTs_args()3871   virtual ~Hbase_deleteAllTs_args() throw() {}
3872 
3873   Text tableName;
3874   Text row;
3875   Text column;
3876   int64_t timestamp;
3877   std::map<Text, Text>  attributes;
3878 
3879   _Hbase_deleteAllTs_args__isset __isset;
3880 
__set_tableName(const Text & val)3881   void __set_tableName(const Text& val) {
3882     tableName = val;
3883   }
3884 
__set_row(const Text & val)3885   void __set_row(const Text& val) {
3886     row = val;
3887   }
3888 
__set_column(const Text & val)3889   void __set_column(const Text& val) {
3890     column = val;
3891   }
3892 
__set_timestamp(const int64_t val)3893   void __set_timestamp(const int64_t val) {
3894     timestamp = val;
3895   }
3896 
__set_attributes(const std::map<Text,Text> & val)3897   void __set_attributes(const std::map<Text, Text> & val) {
3898     attributes = val;
3899   }
3900 
3901   bool operator == (const Hbase_deleteAllTs_args & rhs) const
3902   {
3903     if (!(tableName == rhs.tableName))
3904       return false;
3905     if (!(row == rhs.row))
3906       return false;
3907     if (!(column == rhs.column))
3908       return false;
3909     if (!(timestamp == rhs.timestamp))
3910       return false;
3911     if (!(attributes == rhs.attributes))
3912       return false;
3913     return true;
3914   }
3915   bool operator != (const Hbase_deleteAllTs_args &rhs) const {
3916     return !(*this == rhs);
3917   }
3918 
3919   bool operator < (const Hbase_deleteAllTs_args & ) const;
3920 
3921   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3922   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3923 
3924 };
3925 
3926 
3927 class Hbase_deleteAllTs_pargs {
3928  public:
3929 
3930 
~Hbase_deleteAllTs_pargs()3931   virtual ~Hbase_deleteAllTs_pargs() throw() {}
3932 
3933   const Text* tableName;
3934   const Text* row;
3935   const Text* column;
3936   const int64_t* timestamp;
3937   const std::map<Text, Text> * attributes;
3938 
3939   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3940 
3941 };
3942 
3943 typedef struct _Hbase_deleteAllTs_result__isset {
_Hbase_deleteAllTs_result__isset_Hbase_deleteAllTs_result__isset3944   _Hbase_deleteAllTs_result__isset() : io(false) {}
3945   bool io;
3946 } _Hbase_deleteAllTs_result__isset;
3947 
3948 class Hbase_deleteAllTs_result {
3949  public:
3950 
Hbase_deleteAllTs_result()3951   Hbase_deleteAllTs_result() {
3952   }
3953 
~Hbase_deleteAllTs_result()3954   virtual ~Hbase_deleteAllTs_result() throw() {}
3955 
3956   IOError io;
3957 
3958   _Hbase_deleteAllTs_result__isset __isset;
3959 
__set_io(const IOError & val)3960   void __set_io(const IOError& val) {
3961     io = val;
3962   }
3963 
3964   bool operator == (const Hbase_deleteAllTs_result & rhs) const
3965   {
3966     if (!(io == rhs.io))
3967       return false;
3968     return true;
3969   }
3970   bool operator != (const Hbase_deleteAllTs_result &rhs) const {
3971     return !(*this == rhs);
3972   }
3973 
3974   bool operator < (const Hbase_deleteAllTs_result & ) const;
3975 
3976   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3977   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
3978 
3979 };
3980 
3981 typedef struct _Hbase_deleteAllTs_presult__isset {
_Hbase_deleteAllTs_presult__isset_Hbase_deleteAllTs_presult__isset3982   _Hbase_deleteAllTs_presult__isset() : io(false) {}
3983   bool io;
3984 } _Hbase_deleteAllTs_presult__isset;
3985 
3986 class Hbase_deleteAllTs_presult {
3987  public:
3988 
3989 
~Hbase_deleteAllTs_presult()3990   virtual ~Hbase_deleteAllTs_presult() throw() {}
3991 
3992   IOError io;
3993 
3994   _Hbase_deleteAllTs_presult__isset __isset;
3995 
3996   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
3997 
3998 };
3999 
4000 typedef struct _Hbase_deleteAllRow_args__isset {
_Hbase_deleteAllRow_args__isset_Hbase_deleteAllRow_args__isset4001   _Hbase_deleteAllRow_args__isset() : tableName(false), row(false), attributes(false) {}
4002   bool tableName;
4003   bool row;
4004   bool attributes;
4005 } _Hbase_deleteAllRow_args__isset;
4006 
4007 class Hbase_deleteAllRow_args {
4008  public:
4009 
Hbase_deleteAllRow_args()4010   Hbase_deleteAllRow_args() : tableName(), row() {
4011   }
4012 
~Hbase_deleteAllRow_args()4013   virtual ~Hbase_deleteAllRow_args() throw() {}
4014 
4015   Text tableName;
4016   Text row;
4017   std::map<Text, Text>  attributes;
4018 
4019   _Hbase_deleteAllRow_args__isset __isset;
4020 
__set_tableName(const Text & val)4021   void __set_tableName(const Text& val) {
4022     tableName = val;
4023   }
4024 
__set_row(const Text & val)4025   void __set_row(const Text& val) {
4026     row = val;
4027   }
4028 
__set_attributes(const std::map<Text,Text> & val)4029   void __set_attributes(const std::map<Text, Text> & val) {
4030     attributes = val;
4031   }
4032 
4033   bool operator == (const Hbase_deleteAllRow_args & rhs) const
4034   {
4035     if (!(tableName == rhs.tableName))
4036       return false;
4037     if (!(row == rhs.row))
4038       return false;
4039     if (!(attributes == rhs.attributes))
4040       return false;
4041     return true;
4042   }
4043   bool operator != (const Hbase_deleteAllRow_args &rhs) const {
4044     return !(*this == rhs);
4045   }
4046 
4047   bool operator < (const Hbase_deleteAllRow_args & ) const;
4048 
4049   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
4050   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
4051 
4052 };
4053 
4054 
4055 class Hbase_deleteAllRow_pargs {
4056  public:
4057 
4058 
~Hbase_deleteAllRow_pargs()4059   virtual ~Hbase_deleteAllRow_pargs() throw() {}
4060 
4061   const Text* tableName;
4062   const Text* row;
4063   const std::map<Text, Text> * attributes;
4064 
4065   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
4066 
4067 };
4068 
4069 typedef struct _Hbase_deleteAllRow_result__isset {
_Hbase_deleteAllRow_result__isset_Hbase_deleteAllRow_result__isset4070   _Hbase_deleteAllRow_result__isset() : io(false) {}
4071   bool io;
4072 } _Hbase_deleteAllRow_result__isset;
4073 
4074 class Hbase_deleteAllRow_result {
4075  public:
4076 
Hbase_deleteAllRow_result()4077   Hbase_deleteAllRow_result() {
4078   }
4079 
~Hbase_deleteAllRow_result()4080   virtual ~Hbase_deleteAllRow_result() throw() {}
4081 
4082   IOError io;
4083 
4084   _Hbase_deleteAllRow_result__isset __isset;
4085 
__set_io(const IOError & val)4086   void __set_io(const IOError& val) {
4087     io = val;
4088   }
4089 
4090   bool operator == (const Hbase_deleteAllRow_result & rhs) const
4091   {
4092     if (!(io == rhs.io))
4093       return false;
4094     return true;
4095   }
4096   bool operator != (const Hbase_deleteAllRow_result &rhs) const {
4097     return !(*this == rhs);
4098   }
4099 
4100   bool operator < (const Hbase_deleteAllRow_result & ) const;
4101 
4102   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
4103   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
4104 
4105 };
4106 
4107 typedef struct _Hbase_deleteAllRow_presult__isset {
_Hbase_deleteAllRow_presult__isset_Hbase_deleteAllRow_presult__isset4108   _Hbase_deleteAllRow_presult__isset() : io(false) {}
4109   bool io;
4110 } _Hbase_deleteAllRow_presult__isset;
4111 
4112 class Hbase_deleteAllRow_presult {
4113  public:
4114 
4115 
~Hbase_deleteAllRow_presult()4116   virtual ~Hbase_deleteAllRow_presult() throw() {}
4117 
4118   IOError io;
4119 
4120   _Hbase_deleteAllRow_presult__isset __isset;
4121 
4122   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
4123 
4124 };
4125 
4126 typedef struct _Hbase_increment_args__isset {
_Hbase_increment_args__isset_Hbase_increment_args__isset4127   _Hbase_increment_args__isset() : increment(false) {}
4128   bool increment;
4129 } _Hbase_increment_args__isset;
4130 
4131 class Hbase_increment_args {
4132  public:
4133 
Hbase_increment_args()4134   Hbase_increment_args() {
4135   }
4136 
~Hbase_increment_args()4137   virtual ~Hbase_increment_args() throw() {}
4138 
4139   TIncrement increment;
4140 
4141   _Hbase_increment_args__isset __isset;
4142 
__set_increment(const TIncrement & val)4143   void __set_increment(const TIncrement& val) {
4144     increment = val;
4145   }
4146 
4147   bool operator == (const Hbase_increment_args & rhs) const
4148   {
4149     if (!(increment == rhs.increment))
4150       return false;
4151     return true;
4152   }
4153   bool operator != (const Hbase_increment_args &rhs) const {
4154     return !(*this == rhs);
4155   }
4156 
4157   bool operator < (const Hbase_increment_args & ) const;
4158 
4159   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
4160   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
4161 
4162 };
4163 
4164 
4165 class Hbase_increment_pargs {
4166  public:
4167 
4168 
~Hbase_increment_pargs()4169   virtual ~Hbase_increment_pargs() throw() {}
4170 
4171   const TIncrement* increment;
4172 
4173   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
4174 
4175 };
4176 
4177 typedef struct _Hbase_increment_result__isset {
_Hbase_increment_result__isset_Hbase_increment_result__isset4178   _Hbase_increment_result__isset() : io(false) {}
4179   bool io;
4180 } _Hbase_increment_result__isset;
4181 
4182 class Hbase_increment_result {
4183  public:
4184 
Hbase_increment_result()4185   Hbase_increment_result() {
4186   }
4187 
~Hbase_increment_result()4188   virtual ~Hbase_increment_result() throw() {}
4189 
4190   IOError io;
4191 
4192   _Hbase_increment_result__isset __isset;
4193 
__set_io(const IOError & val)4194   void __set_io(const IOError& val) {
4195     io = val;
4196   }
4197 
4198   bool operator == (const Hbase_increment_result & rhs) const
4199   {
4200     if (!(io == rhs.io))
4201       return false;
4202     return true;
4203   }
4204   bool operator != (const Hbase_increment_result &rhs) const {
4205     return !(*this == rhs);
4206   }
4207 
4208   bool operator < (const Hbase_increment_result & ) const;
4209 
4210   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
4211   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
4212 
4213 };
4214 
4215 typedef struct _Hbase_increment_presult__isset {
_Hbase_increment_presult__isset_Hbase_increment_presult__isset4216   _Hbase_increment_presult__isset() : io(false) {}
4217   bool io;
4218 } _Hbase_increment_presult__isset;
4219 
4220 class Hbase_increment_presult {
4221  public:
4222 
4223 
~Hbase_increment_presult()4224   virtual ~Hbase_increment_presult() throw() {}
4225 
4226   IOError io;
4227 
4228   _Hbase_increment_presult__isset __isset;
4229 
4230   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
4231 
4232 };
4233 
4234 typedef struct _Hbase_incrementRows_args__isset {
_Hbase_incrementRows_args__isset_Hbase_incrementRows_args__isset4235   _Hbase_incrementRows_args__isset() : increments(false) {}
4236   bool increments;
4237 } _Hbase_incrementRows_args__isset;
4238 
4239 class Hbase_incrementRows_args {
4240  public:
4241 
Hbase_incrementRows_args()4242   Hbase_incrementRows_args() {
4243   }
4244 
~Hbase_incrementRows_args()4245   virtual ~Hbase_incrementRows_args() throw() {}
4246 
4247   std::vector<TIncrement>  increments;
4248 
4249   _Hbase_incrementRows_args__isset __isset;
4250 
__set_increments(const std::vector<TIncrement> & val)4251   void __set_increments(const std::vector<TIncrement> & val) {
4252     increments = val;
4253   }
4254 
4255   bool operator == (const Hbase_incrementRows_args & rhs) const
4256   {
4257     if (!(increments == rhs.increments))
4258       return false;
4259     return true;
4260   }
4261   bool operator != (const Hbase_incrementRows_args &rhs) const {
4262     return !(*this == rhs);
4263   }
4264 
4265   bool operator < (const Hbase_incrementRows_args & ) const;
4266 
4267   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
4268   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
4269 
4270 };
4271 
4272 
4273 class Hbase_incrementRows_pargs {
4274  public:
4275 
4276 
~Hbase_incrementRows_pargs()4277   virtual ~Hbase_incrementRows_pargs() throw() {}
4278 
4279   const std::vector<TIncrement> * increments;
4280 
4281   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
4282 
4283 };
4284 
4285 typedef struct _Hbase_incrementRows_result__isset {
_Hbase_incrementRows_result__isset_Hbase_incrementRows_result__isset4286   _Hbase_incrementRows_result__isset() : io(false) {}
4287   bool io;
4288 } _Hbase_incrementRows_result__isset;
4289 
4290 class Hbase_incrementRows_result {
4291  public:
4292 
Hbase_incrementRows_result()4293   Hbase_incrementRows_result() {
4294   }
4295 
~Hbase_incrementRows_result()4296   virtual ~Hbase_incrementRows_result() throw() {}
4297 
4298   IOError io;
4299 
4300   _Hbase_incrementRows_result__isset __isset;
4301 
__set_io(const IOError & val)4302   void __set_io(const IOError& val) {
4303     io = val;
4304   }
4305 
4306   bool operator == (const Hbase_incrementRows_result & rhs) const
4307   {
4308     if (!(io == rhs.io))
4309       return false;
4310     return true;
4311   }
4312   bool operator != (const Hbase_incrementRows_result &rhs) const {
4313     return !(*this == rhs);
4314   }
4315 
4316   bool operator < (const Hbase_incrementRows_result & ) const;
4317 
4318   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
4319   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
4320 
4321 };
4322 
4323 typedef struct _Hbase_incrementRows_presult__isset {
_Hbase_incrementRows_presult__isset_Hbase_incrementRows_presult__isset4324   _Hbase_incrementRows_presult__isset() : io(false) {}
4325   bool io;
4326 } _Hbase_incrementRows_presult__isset;
4327 
4328 class Hbase_incrementRows_presult {
4329  public:
4330 
4331 
~Hbase_incrementRows_presult()4332   virtual ~Hbase_incrementRows_presult() throw() {}
4333 
4334   IOError io;
4335 
4336   _Hbase_incrementRows_presult__isset __isset;
4337 
4338   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
4339 
4340 };
4341 
4342 typedef struct _Hbase_deleteAllRowTs_args__isset {
_Hbase_deleteAllRowTs_args__isset_Hbase_deleteAllRowTs_args__isset4343   _Hbase_deleteAllRowTs_args__isset() : tableName(false), row(false), timestamp(false), attributes(false) {}
4344   bool tableName;
4345   bool row;
4346   bool timestamp;
4347   bool attributes;
4348 } _Hbase_deleteAllRowTs_args__isset;
4349 
4350 class Hbase_deleteAllRowTs_args {
4351  public:
4352 
Hbase_deleteAllRowTs_args()4353   Hbase_deleteAllRowTs_args() : tableName(), row(), timestamp(0) {
4354   }
4355 
~Hbase_deleteAllRowTs_args()4356   virtual ~Hbase_deleteAllRowTs_args() throw() {}
4357 
4358   Text tableName;
4359   Text row;
4360   int64_t timestamp;
4361   std::map<Text, Text>  attributes;
4362 
4363   _Hbase_deleteAllRowTs_args__isset __isset;
4364 
__set_tableName(const Text & val)4365   void __set_tableName(const Text& val) {
4366     tableName = val;
4367   }
4368 
__set_row(const Text & val)4369   void __set_row(const Text& val) {
4370     row = val;
4371   }
4372 
__set_timestamp(const int64_t val)4373   void __set_timestamp(const int64_t val) {
4374     timestamp = val;
4375   }
4376 
__set_attributes(const std::map<Text,Text> & val)4377   void __set_attributes(const std::map<Text, Text> & val) {
4378     attributes = val;
4379   }
4380 
4381   bool operator == (const Hbase_deleteAllRowTs_args & rhs) const
4382   {
4383     if (!(tableName == rhs.tableName))
4384       return false;
4385     if (!(row == rhs.row))
4386       return false;
4387     if (!(timestamp == rhs.timestamp))
4388       return false;
4389     if (!(attributes == rhs.attributes))
4390       return false;
4391     return true;
4392   }
4393   bool operator != (const Hbase_deleteAllRowTs_args &rhs) const {
4394     return !(*this == rhs);
4395   }
4396 
4397   bool operator < (const Hbase_deleteAllRowTs_args & ) const;
4398 
4399   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
4400   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
4401 
4402 };
4403 
4404 
4405 class Hbase_deleteAllRowTs_pargs {
4406  public:
4407 
4408 
~Hbase_deleteAllRowTs_pargs()4409   virtual ~Hbase_deleteAllRowTs_pargs() throw() {}
4410 
4411   const Text* tableName;
4412   const Text* row;
4413   const int64_t* timestamp;
4414   const std::map<Text, Text> * attributes;
4415 
4416   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
4417 
4418 };
4419 
4420 typedef struct _Hbase_deleteAllRowTs_result__isset {
_Hbase_deleteAllRowTs_result__isset_Hbase_deleteAllRowTs_result__isset4421   _Hbase_deleteAllRowTs_result__isset() : io(false) {}
4422   bool io;
4423 } _Hbase_deleteAllRowTs_result__isset;
4424 
4425 class Hbase_deleteAllRowTs_result {
4426  public:
4427 
Hbase_deleteAllRowTs_result()4428   Hbase_deleteAllRowTs_result() {
4429   }
4430 
~Hbase_deleteAllRowTs_result()4431   virtual ~Hbase_deleteAllRowTs_result() throw() {}
4432 
4433   IOError io;
4434 
4435   _Hbase_deleteAllRowTs_result__isset __isset;
4436 
__set_io(const IOError & val)4437   void __set_io(const IOError& val) {
4438     io = val;
4439   }
4440 
4441   bool operator == (const Hbase_deleteAllRowTs_result & rhs) const
4442   {
4443     if (!(io == rhs.io))
4444       return false;
4445     return true;
4446   }
4447   bool operator != (const Hbase_deleteAllRowTs_result &rhs) const {
4448     return !(*this == rhs);
4449   }
4450 
4451   bool operator < (const Hbase_deleteAllRowTs_result & ) const;
4452 
4453   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
4454   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
4455 
4456 };
4457 
4458 typedef struct _Hbase_deleteAllRowTs_presult__isset {
_Hbase_deleteAllRowTs_presult__isset_Hbase_deleteAllRowTs_presult__isset4459   _Hbase_deleteAllRowTs_presult__isset() : io(false) {}
4460   bool io;
4461 } _Hbase_deleteAllRowTs_presult__isset;
4462 
4463 class Hbase_deleteAllRowTs_presult {
4464  public:
4465 
4466 
~Hbase_deleteAllRowTs_presult()4467   virtual ~Hbase_deleteAllRowTs_presult() throw() {}
4468 
4469   IOError io;
4470 
4471   _Hbase_deleteAllRowTs_presult__isset __isset;
4472 
4473   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
4474 
4475 };
4476 
4477 typedef struct _Hbase_scannerOpenWithScan_args__isset {
_Hbase_scannerOpenWithScan_args__isset_Hbase_scannerOpenWithScan_args__isset4478   _Hbase_scannerOpenWithScan_args__isset() : tableName(false), scan(false), attributes(false) {}
4479   bool tableName;
4480   bool scan;
4481   bool attributes;
4482 } _Hbase_scannerOpenWithScan_args__isset;
4483 
4484 class Hbase_scannerOpenWithScan_args {
4485  public:
4486 
Hbase_scannerOpenWithScan_args()4487   Hbase_scannerOpenWithScan_args() : tableName() {
4488   }
4489 
~Hbase_scannerOpenWithScan_args()4490   virtual ~Hbase_scannerOpenWithScan_args() throw() {}
4491 
4492   Text tableName;
4493   TScan scan;
4494   std::map<Text, Text>  attributes;
4495 
4496   _Hbase_scannerOpenWithScan_args__isset __isset;
4497 
__set_tableName(const Text & val)4498   void __set_tableName(const Text& val) {
4499     tableName = val;
4500   }
4501 
__set_scan(const TScan & val)4502   void __set_scan(const TScan& val) {
4503     scan = val;
4504   }
4505 
__set_attributes(const std::map<Text,Text> & val)4506   void __set_attributes(const std::map<Text, Text> & val) {
4507     attributes = val;
4508   }
4509 
4510   bool operator == (const Hbase_scannerOpenWithScan_args & rhs) const
4511   {
4512     if (!(tableName == rhs.tableName))
4513       return false;
4514     if (!(scan == rhs.scan))
4515       return false;
4516     if (!(attributes == rhs.attributes))
4517       return false;
4518     return true;
4519   }
4520   bool operator != (const Hbase_scannerOpenWithScan_args &rhs) const {
4521     return !(*this == rhs);
4522   }
4523 
4524   bool operator < (const Hbase_scannerOpenWithScan_args & ) const;
4525 
4526   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
4527   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
4528 
4529 };
4530 
4531 
4532 class Hbase_scannerOpenWithScan_pargs {
4533  public:
4534 
4535 
~Hbase_scannerOpenWithScan_pargs()4536   virtual ~Hbase_scannerOpenWithScan_pargs() throw() {}
4537 
4538   const Text* tableName;
4539   const TScan* scan;
4540   const std::map<Text, Text> * attributes;
4541 
4542   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
4543 
4544 };
4545 
4546 typedef struct _Hbase_scannerOpenWithScan_result__isset {
_Hbase_scannerOpenWithScan_result__isset_Hbase_scannerOpenWithScan_result__isset4547   _Hbase_scannerOpenWithScan_result__isset() : success(false), io(false) {}
4548   bool success;
4549   bool io;
4550 } _Hbase_scannerOpenWithScan_result__isset;
4551 
4552 class Hbase_scannerOpenWithScan_result {
4553  public:
4554 
Hbase_scannerOpenWithScan_result()4555   Hbase_scannerOpenWithScan_result() : success(0) {
4556   }
4557 
~Hbase_scannerOpenWithScan_result()4558   virtual ~Hbase_scannerOpenWithScan_result() throw() {}
4559 
4560   ScannerID success;
4561   IOError io;
4562 
4563   _Hbase_scannerOpenWithScan_result__isset __isset;
4564 
__set_success(const ScannerID val)4565   void __set_success(const ScannerID val) {
4566     success = val;
4567   }
4568 
__set_io(const IOError & val)4569   void __set_io(const IOError& val) {
4570     io = val;
4571   }
4572 
4573   bool operator == (const Hbase_scannerOpenWithScan_result & rhs) const
4574   {
4575     if (!(success == rhs.success))
4576       return false;
4577     if (!(io == rhs.io))
4578       return false;
4579     return true;
4580   }
4581   bool operator != (const Hbase_scannerOpenWithScan_result &rhs) const {
4582     return !(*this == rhs);
4583   }
4584 
4585   bool operator < (const Hbase_scannerOpenWithScan_result & ) const;
4586 
4587   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
4588   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
4589 
4590 };
4591 
4592 typedef struct _Hbase_scannerOpenWithScan_presult__isset {
_Hbase_scannerOpenWithScan_presult__isset_Hbase_scannerOpenWithScan_presult__isset4593   _Hbase_scannerOpenWithScan_presult__isset() : success(false), io(false) {}
4594   bool success;
4595   bool io;
4596 } _Hbase_scannerOpenWithScan_presult__isset;
4597 
4598 class Hbase_scannerOpenWithScan_presult {
4599  public:
4600 
4601 
~Hbase_scannerOpenWithScan_presult()4602   virtual ~Hbase_scannerOpenWithScan_presult() throw() {}
4603 
4604   ScannerID* success;
4605   IOError io;
4606 
4607   _Hbase_scannerOpenWithScan_presult__isset __isset;
4608 
4609   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
4610 
4611 };
4612 
4613 typedef struct _Hbase_scannerOpen_args__isset {
_Hbase_scannerOpen_args__isset_Hbase_scannerOpen_args__isset4614   _Hbase_scannerOpen_args__isset() : tableName(false), startRow(false), columns(false), attributes(false) {}
4615   bool tableName;
4616   bool startRow;
4617   bool columns;
4618   bool attributes;
4619 } _Hbase_scannerOpen_args__isset;
4620 
4621 class Hbase_scannerOpen_args {
4622  public:
4623 
Hbase_scannerOpen_args()4624   Hbase_scannerOpen_args() : tableName(), startRow() {
4625   }
4626 
~Hbase_scannerOpen_args()4627   virtual ~Hbase_scannerOpen_args() throw() {}
4628 
4629   Text tableName;
4630   Text startRow;
4631   std::vector<Text>  columns;
4632   std::map<Text, Text>  attributes;
4633 
4634   _Hbase_scannerOpen_args__isset __isset;
4635 
__set_tableName(const Text & val)4636   void __set_tableName(const Text& val) {
4637     tableName = val;
4638   }
4639 
__set_startRow(const Text & val)4640   void __set_startRow(const Text& val) {
4641     startRow = val;
4642   }
4643 
__set_columns(const std::vector<Text> & val)4644   void __set_columns(const std::vector<Text> & val) {
4645     columns = val;
4646   }
4647 
__set_attributes(const std::map<Text,Text> & val)4648   void __set_attributes(const std::map<Text, Text> & val) {
4649     attributes = val;
4650   }
4651 
4652   bool operator == (const Hbase_scannerOpen_args & rhs) const
4653   {
4654     if (!(tableName == rhs.tableName))
4655       return false;
4656     if (!(startRow == rhs.startRow))
4657       return false;
4658     if (!(columns == rhs.columns))
4659       return false;
4660     if (!(attributes == rhs.attributes))
4661       return false;
4662     return true;
4663   }
4664   bool operator != (const Hbase_scannerOpen_args &rhs) const {
4665     return !(*this == rhs);
4666   }
4667 
4668   bool operator < (const Hbase_scannerOpen_args & ) const;
4669 
4670   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
4671   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
4672 
4673 };
4674 
4675 
4676 class Hbase_scannerOpen_pargs {
4677  public:
4678 
4679 
~Hbase_scannerOpen_pargs()4680   virtual ~Hbase_scannerOpen_pargs() throw() {}
4681 
4682   const Text* tableName;
4683   const Text* startRow;
4684   const std::vector<Text> * columns;
4685   const std::map<Text, Text> * attributes;
4686 
4687   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
4688 
4689 };
4690 
4691 typedef struct _Hbase_scannerOpen_result__isset {
_Hbase_scannerOpen_result__isset_Hbase_scannerOpen_result__isset4692   _Hbase_scannerOpen_result__isset() : success(false), io(false) {}
4693   bool success;
4694   bool io;
4695 } _Hbase_scannerOpen_result__isset;
4696 
4697 class Hbase_scannerOpen_result {
4698  public:
4699 
Hbase_scannerOpen_result()4700   Hbase_scannerOpen_result() : success(0) {
4701   }
4702 
~Hbase_scannerOpen_result()4703   virtual ~Hbase_scannerOpen_result() throw() {}
4704 
4705   ScannerID success;
4706   IOError io;
4707 
4708   _Hbase_scannerOpen_result__isset __isset;
4709 
__set_success(const ScannerID val)4710   void __set_success(const ScannerID val) {
4711     success = val;
4712   }
4713 
__set_io(const IOError & val)4714   void __set_io(const IOError& val) {
4715     io = val;
4716   }
4717 
4718   bool operator == (const Hbase_scannerOpen_result & rhs) const
4719   {
4720     if (!(success == rhs.success))
4721       return false;
4722     if (!(io == rhs.io))
4723       return false;
4724     return true;
4725   }
4726   bool operator != (const Hbase_scannerOpen_result &rhs) const {
4727     return !(*this == rhs);
4728   }
4729 
4730   bool operator < (const Hbase_scannerOpen_result & ) const;
4731 
4732   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
4733   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
4734 
4735 };
4736 
4737 typedef struct _Hbase_scannerOpen_presult__isset {
_Hbase_scannerOpen_presult__isset_Hbase_scannerOpen_presult__isset4738   _Hbase_scannerOpen_presult__isset() : success(false), io(false) {}
4739   bool success;
4740   bool io;
4741 } _Hbase_scannerOpen_presult__isset;
4742 
4743 class Hbase_scannerOpen_presult {
4744  public:
4745 
4746 
~Hbase_scannerOpen_presult()4747   virtual ~Hbase_scannerOpen_presult() throw() {}
4748 
4749   ScannerID* success;
4750   IOError io;
4751 
4752   _Hbase_scannerOpen_presult__isset __isset;
4753 
4754   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
4755 
4756 };
4757 
4758 typedef struct _Hbase_scannerOpenWithStop_args__isset {
_Hbase_scannerOpenWithStop_args__isset_Hbase_scannerOpenWithStop_args__isset4759   _Hbase_scannerOpenWithStop_args__isset() : tableName(false), startRow(false), stopRow(false), columns(false), attributes(false) {}
4760   bool tableName;
4761   bool startRow;
4762   bool stopRow;
4763   bool columns;
4764   bool attributes;
4765 } _Hbase_scannerOpenWithStop_args__isset;
4766 
4767 class Hbase_scannerOpenWithStop_args {
4768  public:
4769 
Hbase_scannerOpenWithStop_args()4770   Hbase_scannerOpenWithStop_args() : tableName(), startRow(), stopRow() {
4771   }
4772 
~Hbase_scannerOpenWithStop_args()4773   virtual ~Hbase_scannerOpenWithStop_args() throw() {}
4774 
4775   Text tableName;
4776   Text startRow;
4777   Text stopRow;
4778   std::vector<Text>  columns;
4779   std::map<Text, Text>  attributes;
4780 
4781   _Hbase_scannerOpenWithStop_args__isset __isset;
4782 
__set_tableName(const Text & val)4783   void __set_tableName(const Text& val) {
4784     tableName = val;
4785   }
4786 
__set_startRow(const Text & val)4787   void __set_startRow(const Text& val) {
4788     startRow = val;
4789   }
4790 
__set_stopRow(const Text & val)4791   void __set_stopRow(const Text& val) {
4792     stopRow = val;
4793   }
4794 
__set_columns(const std::vector<Text> & val)4795   void __set_columns(const std::vector<Text> & val) {
4796     columns = val;
4797   }
4798 
__set_attributes(const std::map<Text,Text> & val)4799   void __set_attributes(const std::map<Text, Text> & val) {
4800     attributes = val;
4801   }
4802 
4803   bool operator == (const Hbase_scannerOpenWithStop_args & rhs) const
4804   {
4805     if (!(tableName == rhs.tableName))
4806       return false;
4807     if (!(startRow == rhs.startRow))
4808       return false;
4809     if (!(stopRow == rhs.stopRow))
4810       return false;
4811     if (!(columns == rhs.columns))
4812       return false;
4813     if (!(attributes == rhs.attributes))
4814       return false;
4815     return true;
4816   }
4817   bool operator != (const Hbase_scannerOpenWithStop_args &rhs) const {
4818     return !(*this == rhs);
4819   }
4820 
4821   bool operator < (const Hbase_scannerOpenWithStop_args & ) const;
4822 
4823   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
4824   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
4825 
4826 };
4827 
4828 
4829 class Hbase_scannerOpenWithStop_pargs {
4830  public:
4831 
4832 
~Hbase_scannerOpenWithStop_pargs()4833   virtual ~Hbase_scannerOpenWithStop_pargs() throw() {}
4834 
4835   const Text* tableName;
4836   const Text* startRow;
4837   const Text* stopRow;
4838   const std::vector<Text> * columns;
4839   const std::map<Text, Text> * attributes;
4840 
4841   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
4842 
4843 };
4844 
4845 typedef struct _Hbase_scannerOpenWithStop_result__isset {
_Hbase_scannerOpenWithStop_result__isset_Hbase_scannerOpenWithStop_result__isset4846   _Hbase_scannerOpenWithStop_result__isset() : success(false), io(false) {}
4847   bool success;
4848   bool io;
4849 } _Hbase_scannerOpenWithStop_result__isset;
4850 
4851 class Hbase_scannerOpenWithStop_result {
4852  public:
4853 
Hbase_scannerOpenWithStop_result()4854   Hbase_scannerOpenWithStop_result() : success(0) {
4855   }
4856 
~Hbase_scannerOpenWithStop_result()4857   virtual ~Hbase_scannerOpenWithStop_result() throw() {}
4858 
4859   ScannerID success;
4860   IOError io;
4861 
4862   _Hbase_scannerOpenWithStop_result__isset __isset;
4863 
__set_success(const ScannerID val)4864   void __set_success(const ScannerID val) {
4865     success = val;
4866   }
4867 
__set_io(const IOError & val)4868   void __set_io(const IOError& val) {
4869     io = val;
4870   }
4871 
4872   bool operator == (const Hbase_scannerOpenWithStop_result & rhs) const
4873   {
4874     if (!(success == rhs.success))
4875       return false;
4876     if (!(io == rhs.io))
4877       return false;
4878     return true;
4879   }
4880   bool operator != (const Hbase_scannerOpenWithStop_result &rhs) const {
4881     return !(*this == rhs);
4882   }
4883 
4884   bool operator < (const Hbase_scannerOpenWithStop_result & ) const;
4885 
4886   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
4887   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
4888 
4889 };
4890 
4891 typedef struct _Hbase_scannerOpenWithStop_presult__isset {
_Hbase_scannerOpenWithStop_presult__isset_Hbase_scannerOpenWithStop_presult__isset4892   _Hbase_scannerOpenWithStop_presult__isset() : success(false), io(false) {}
4893   bool success;
4894   bool io;
4895 } _Hbase_scannerOpenWithStop_presult__isset;
4896 
4897 class Hbase_scannerOpenWithStop_presult {
4898  public:
4899 
4900 
~Hbase_scannerOpenWithStop_presult()4901   virtual ~Hbase_scannerOpenWithStop_presult() throw() {}
4902 
4903   ScannerID* success;
4904   IOError io;
4905 
4906   _Hbase_scannerOpenWithStop_presult__isset __isset;
4907 
4908   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
4909 
4910 };
4911 
4912 typedef struct _Hbase_scannerOpenWithPrefix_args__isset {
_Hbase_scannerOpenWithPrefix_args__isset_Hbase_scannerOpenWithPrefix_args__isset4913   _Hbase_scannerOpenWithPrefix_args__isset() : tableName(false), startAndPrefix(false), columns(false), attributes(false) {}
4914   bool tableName;
4915   bool startAndPrefix;
4916   bool columns;
4917   bool attributes;
4918 } _Hbase_scannerOpenWithPrefix_args__isset;
4919 
4920 class Hbase_scannerOpenWithPrefix_args {
4921  public:
4922 
Hbase_scannerOpenWithPrefix_args()4923   Hbase_scannerOpenWithPrefix_args() : tableName(), startAndPrefix() {
4924   }
4925 
~Hbase_scannerOpenWithPrefix_args()4926   virtual ~Hbase_scannerOpenWithPrefix_args() throw() {}
4927 
4928   Text tableName;
4929   Text startAndPrefix;
4930   std::vector<Text>  columns;
4931   std::map<Text, Text>  attributes;
4932 
4933   _Hbase_scannerOpenWithPrefix_args__isset __isset;
4934 
__set_tableName(const Text & val)4935   void __set_tableName(const Text& val) {
4936     tableName = val;
4937   }
4938 
__set_startAndPrefix(const Text & val)4939   void __set_startAndPrefix(const Text& val) {
4940     startAndPrefix = val;
4941   }
4942 
__set_columns(const std::vector<Text> & val)4943   void __set_columns(const std::vector<Text> & val) {
4944     columns = val;
4945   }
4946 
__set_attributes(const std::map<Text,Text> & val)4947   void __set_attributes(const std::map<Text, Text> & val) {
4948     attributes = val;
4949   }
4950 
4951   bool operator == (const Hbase_scannerOpenWithPrefix_args & rhs) const
4952   {
4953     if (!(tableName == rhs.tableName))
4954       return false;
4955     if (!(startAndPrefix == rhs.startAndPrefix))
4956       return false;
4957     if (!(columns == rhs.columns))
4958       return false;
4959     if (!(attributes == rhs.attributes))
4960       return false;
4961     return true;
4962   }
4963   bool operator != (const Hbase_scannerOpenWithPrefix_args &rhs) const {
4964     return !(*this == rhs);
4965   }
4966 
4967   bool operator < (const Hbase_scannerOpenWithPrefix_args & ) const;
4968 
4969   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
4970   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
4971 
4972 };
4973 
4974 
4975 class Hbase_scannerOpenWithPrefix_pargs {
4976  public:
4977 
4978 
~Hbase_scannerOpenWithPrefix_pargs()4979   virtual ~Hbase_scannerOpenWithPrefix_pargs() throw() {}
4980 
4981   const Text* tableName;
4982   const Text* startAndPrefix;
4983   const std::vector<Text> * columns;
4984   const std::map<Text, Text> * attributes;
4985 
4986   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
4987 
4988 };
4989 
4990 typedef struct _Hbase_scannerOpenWithPrefix_result__isset {
_Hbase_scannerOpenWithPrefix_result__isset_Hbase_scannerOpenWithPrefix_result__isset4991   _Hbase_scannerOpenWithPrefix_result__isset() : success(false), io(false) {}
4992   bool success;
4993   bool io;
4994 } _Hbase_scannerOpenWithPrefix_result__isset;
4995 
4996 class Hbase_scannerOpenWithPrefix_result {
4997  public:
4998 
Hbase_scannerOpenWithPrefix_result()4999   Hbase_scannerOpenWithPrefix_result() : success(0) {
5000   }
5001 
~Hbase_scannerOpenWithPrefix_result()5002   virtual ~Hbase_scannerOpenWithPrefix_result() throw() {}
5003 
5004   ScannerID success;
5005   IOError io;
5006 
5007   _Hbase_scannerOpenWithPrefix_result__isset __isset;
5008 
__set_success(const ScannerID val)5009   void __set_success(const ScannerID val) {
5010     success = val;
5011   }
5012 
__set_io(const IOError & val)5013   void __set_io(const IOError& val) {
5014     io = val;
5015   }
5016 
5017   bool operator == (const Hbase_scannerOpenWithPrefix_result & rhs) const
5018   {
5019     if (!(success == rhs.success))
5020       return false;
5021     if (!(io == rhs.io))
5022       return false;
5023     return true;
5024   }
5025   bool operator != (const Hbase_scannerOpenWithPrefix_result &rhs) const {
5026     return !(*this == rhs);
5027   }
5028 
5029   bool operator < (const Hbase_scannerOpenWithPrefix_result & ) const;
5030 
5031   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
5032   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
5033 
5034 };
5035 
5036 typedef struct _Hbase_scannerOpenWithPrefix_presult__isset {
_Hbase_scannerOpenWithPrefix_presult__isset_Hbase_scannerOpenWithPrefix_presult__isset5037   _Hbase_scannerOpenWithPrefix_presult__isset() : success(false), io(false) {}
5038   bool success;
5039   bool io;
5040 } _Hbase_scannerOpenWithPrefix_presult__isset;
5041 
5042 class Hbase_scannerOpenWithPrefix_presult {
5043  public:
5044 
5045 
~Hbase_scannerOpenWithPrefix_presult()5046   virtual ~Hbase_scannerOpenWithPrefix_presult() throw() {}
5047 
5048   ScannerID* success;
5049   IOError io;
5050 
5051   _Hbase_scannerOpenWithPrefix_presult__isset __isset;
5052 
5053   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
5054 
5055 };
5056 
5057 typedef struct _Hbase_scannerOpenTs_args__isset {
_Hbase_scannerOpenTs_args__isset_Hbase_scannerOpenTs_args__isset5058   _Hbase_scannerOpenTs_args__isset() : tableName(false), startRow(false), columns(false), timestamp(false), attributes(false) {}
5059   bool tableName;
5060   bool startRow;
5061   bool columns;
5062   bool timestamp;
5063   bool attributes;
5064 } _Hbase_scannerOpenTs_args__isset;
5065 
5066 class Hbase_scannerOpenTs_args {
5067  public:
5068 
Hbase_scannerOpenTs_args()5069   Hbase_scannerOpenTs_args() : tableName(), startRow(), timestamp(0) {
5070   }
5071 
~Hbase_scannerOpenTs_args()5072   virtual ~Hbase_scannerOpenTs_args() throw() {}
5073 
5074   Text tableName;
5075   Text startRow;
5076   std::vector<Text>  columns;
5077   int64_t timestamp;
5078   std::map<Text, Text>  attributes;
5079 
5080   _Hbase_scannerOpenTs_args__isset __isset;
5081 
__set_tableName(const Text & val)5082   void __set_tableName(const Text& val) {
5083     tableName = val;
5084   }
5085 
__set_startRow(const Text & val)5086   void __set_startRow(const Text& val) {
5087     startRow = val;
5088   }
5089 
__set_columns(const std::vector<Text> & val)5090   void __set_columns(const std::vector<Text> & val) {
5091     columns = val;
5092   }
5093 
__set_timestamp(const int64_t val)5094   void __set_timestamp(const int64_t val) {
5095     timestamp = val;
5096   }
5097 
__set_attributes(const std::map<Text,Text> & val)5098   void __set_attributes(const std::map<Text, Text> & val) {
5099     attributes = val;
5100   }
5101 
5102   bool operator == (const Hbase_scannerOpenTs_args & rhs) const
5103   {
5104     if (!(tableName == rhs.tableName))
5105       return false;
5106     if (!(startRow == rhs.startRow))
5107       return false;
5108     if (!(columns == rhs.columns))
5109       return false;
5110     if (!(timestamp == rhs.timestamp))
5111       return false;
5112     if (!(attributes == rhs.attributes))
5113       return false;
5114     return true;
5115   }
5116   bool operator != (const Hbase_scannerOpenTs_args &rhs) const {
5117     return !(*this == rhs);
5118   }
5119 
5120   bool operator < (const Hbase_scannerOpenTs_args & ) const;
5121 
5122   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
5123   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
5124 
5125 };
5126 
5127 
5128 class Hbase_scannerOpenTs_pargs {
5129  public:
5130 
5131 
~Hbase_scannerOpenTs_pargs()5132   virtual ~Hbase_scannerOpenTs_pargs() throw() {}
5133 
5134   const Text* tableName;
5135   const Text* startRow;
5136   const std::vector<Text> * columns;
5137   const int64_t* timestamp;
5138   const std::map<Text, Text> * attributes;
5139 
5140   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
5141 
5142 };
5143 
5144 typedef struct _Hbase_scannerOpenTs_result__isset {
_Hbase_scannerOpenTs_result__isset_Hbase_scannerOpenTs_result__isset5145   _Hbase_scannerOpenTs_result__isset() : success(false), io(false) {}
5146   bool success;
5147   bool io;
5148 } _Hbase_scannerOpenTs_result__isset;
5149 
5150 class Hbase_scannerOpenTs_result {
5151  public:
5152 
Hbase_scannerOpenTs_result()5153   Hbase_scannerOpenTs_result() : success(0) {
5154   }
5155 
~Hbase_scannerOpenTs_result()5156   virtual ~Hbase_scannerOpenTs_result() throw() {}
5157 
5158   ScannerID success;
5159   IOError io;
5160 
5161   _Hbase_scannerOpenTs_result__isset __isset;
5162 
__set_success(const ScannerID val)5163   void __set_success(const ScannerID val) {
5164     success = val;
5165   }
5166 
__set_io(const IOError & val)5167   void __set_io(const IOError& val) {
5168     io = val;
5169   }
5170 
5171   bool operator == (const Hbase_scannerOpenTs_result & rhs) const
5172   {
5173     if (!(success == rhs.success))
5174       return false;
5175     if (!(io == rhs.io))
5176       return false;
5177     return true;
5178   }
5179   bool operator != (const Hbase_scannerOpenTs_result &rhs) const {
5180     return !(*this == rhs);
5181   }
5182 
5183   bool operator < (const Hbase_scannerOpenTs_result & ) const;
5184 
5185   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
5186   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
5187 
5188 };
5189 
5190 typedef struct _Hbase_scannerOpenTs_presult__isset {
_Hbase_scannerOpenTs_presult__isset_Hbase_scannerOpenTs_presult__isset5191   _Hbase_scannerOpenTs_presult__isset() : success(false), io(false) {}
5192   bool success;
5193   bool io;
5194 } _Hbase_scannerOpenTs_presult__isset;
5195 
5196 class Hbase_scannerOpenTs_presult {
5197  public:
5198 
5199 
~Hbase_scannerOpenTs_presult()5200   virtual ~Hbase_scannerOpenTs_presult() throw() {}
5201 
5202   ScannerID* success;
5203   IOError io;
5204 
5205   _Hbase_scannerOpenTs_presult__isset __isset;
5206 
5207   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
5208 
5209 };
5210 
5211 typedef struct _Hbase_scannerOpenWithStopTs_args__isset {
_Hbase_scannerOpenWithStopTs_args__isset_Hbase_scannerOpenWithStopTs_args__isset5212   _Hbase_scannerOpenWithStopTs_args__isset() : tableName(false), startRow(false), stopRow(false), columns(false), timestamp(false), attributes(false) {}
5213   bool tableName;
5214   bool startRow;
5215   bool stopRow;
5216   bool columns;
5217   bool timestamp;
5218   bool attributes;
5219 } _Hbase_scannerOpenWithStopTs_args__isset;
5220 
5221 class Hbase_scannerOpenWithStopTs_args {
5222  public:
5223 
Hbase_scannerOpenWithStopTs_args()5224   Hbase_scannerOpenWithStopTs_args() : tableName(), startRow(), stopRow(), timestamp(0) {
5225   }
5226 
~Hbase_scannerOpenWithStopTs_args()5227   virtual ~Hbase_scannerOpenWithStopTs_args() throw() {}
5228 
5229   Text tableName;
5230   Text startRow;
5231   Text stopRow;
5232   std::vector<Text>  columns;
5233   int64_t timestamp;
5234   std::map<Text, Text>  attributes;
5235 
5236   _Hbase_scannerOpenWithStopTs_args__isset __isset;
5237 
__set_tableName(const Text & val)5238   void __set_tableName(const Text& val) {
5239     tableName = val;
5240   }
5241 
__set_startRow(const Text & val)5242   void __set_startRow(const Text& val) {
5243     startRow = val;
5244   }
5245 
__set_stopRow(const Text & val)5246   void __set_stopRow(const Text& val) {
5247     stopRow = val;
5248   }
5249 
__set_columns(const std::vector<Text> & val)5250   void __set_columns(const std::vector<Text> & val) {
5251     columns = val;
5252   }
5253 
__set_timestamp(const int64_t val)5254   void __set_timestamp(const int64_t val) {
5255     timestamp = val;
5256   }
5257 
__set_attributes(const std::map<Text,Text> & val)5258   void __set_attributes(const std::map<Text, Text> & val) {
5259     attributes = val;
5260   }
5261 
5262   bool operator == (const Hbase_scannerOpenWithStopTs_args & rhs) const
5263   {
5264     if (!(tableName == rhs.tableName))
5265       return false;
5266     if (!(startRow == rhs.startRow))
5267       return false;
5268     if (!(stopRow == rhs.stopRow))
5269       return false;
5270     if (!(columns == rhs.columns))
5271       return false;
5272     if (!(timestamp == rhs.timestamp))
5273       return false;
5274     if (!(attributes == rhs.attributes))
5275       return false;
5276     return true;
5277   }
5278   bool operator != (const Hbase_scannerOpenWithStopTs_args &rhs) const {
5279     return !(*this == rhs);
5280   }
5281 
5282   bool operator < (const Hbase_scannerOpenWithStopTs_args & ) const;
5283 
5284   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
5285   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
5286 
5287 };
5288 
5289 
5290 class Hbase_scannerOpenWithStopTs_pargs {
5291  public:
5292 
5293 
~Hbase_scannerOpenWithStopTs_pargs()5294   virtual ~Hbase_scannerOpenWithStopTs_pargs() throw() {}
5295 
5296   const Text* tableName;
5297   const Text* startRow;
5298   const Text* stopRow;
5299   const std::vector<Text> * columns;
5300   const int64_t* timestamp;
5301   const std::map<Text, Text> * attributes;
5302 
5303   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
5304 
5305 };
5306 
5307 typedef struct _Hbase_scannerOpenWithStopTs_result__isset {
_Hbase_scannerOpenWithStopTs_result__isset_Hbase_scannerOpenWithStopTs_result__isset5308   _Hbase_scannerOpenWithStopTs_result__isset() : success(false), io(false) {}
5309   bool success;
5310   bool io;
5311 } _Hbase_scannerOpenWithStopTs_result__isset;
5312 
5313 class Hbase_scannerOpenWithStopTs_result {
5314  public:
5315 
Hbase_scannerOpenWithStopTs_result()5316   Hbase_scannerOpenWithStopTs_result() : success(0) {
5317   }
5318 
~Hbase_scannerOpenWithStopTs_result()5319   virtual ~Hbase_scannerOpenWithStopTs_result() throw() {}
5320 
5321   ScannerID success;
5322   IOError io;
5323 
5324   _Hbase_scannerOpenWithStopTs_result__isset __isset;
5325 
__set_success(const ScannerID val)5326   void __set_success(const ScannerID val) {
5327     success = val;
5328   }
5329 
__set_io(const IOError & val)5330   void __set_io(const IOError& val) {
5331     io = val;
5332   }
5333 
5334   bool operator == (const Hbase_scannerOpenWithStopTs_result & rhs) const
5335   {
5336     if (!(success == rhs.success))
5337       return false;
5338     if (!(io == rhs.io))
5339       return false;
5340     return true;
5341   }
5342   bool operator != (const Hbase_scannerOpenWithStopTs_result &rhs) const {
5343     return !(*this == rhs);
5344   }
5345 
5346   bool operator < (const Hbase_scannerOpenWithStopTs_result & ) const;
5347 
5348   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
5349   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
5350 
5351 };
5352 
5353 typedef struct _Hbase_scannerOpenWithStopTs_presult__isset {
_Hbase_scannerOpenWithStopTs_presult__isset_Hbase_scannerOpenWithStopTs_presult__isset5354   _Hbase_scannerOpenWithStopTs_presult__isset() : success(false), io(false) {}
5355   bool success;
5356   bool io;
5357 } _Hbase_scannerOpenWithStopTs_presult__isset;
5358 
5359 class Hbase_scannerOpenWithStopTs_presult {
5360  public:
5361 
5362 
~Hbase_scannerOpenWithStopTs_presult()5363   virtual ~Hbase_scannerOpenWithStopTs_presult() throw() {}
5364 
5365   ScannerID* success;
5366   IOError io;
5367 
5368   _Hbase_scannerOpenWithStopTs_presult__isset __isset;
5369 
5370   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
5371 
5372 };
5373 
5374 typedef struct _Hbase_scannerGet_args__isset {
_Hbase_scannerGet_args__isset_Hbase_scannerGet_args__isset5375   _Hbase_scannerGet_args__isset() : id(false) {}
5376   bool id;
5377 } _Hbase_scannerGet_args__isset;
5378 
5379 class Hbase_scannerGet_args {
5380  public:
5381 
Hbase_scannerGet_args()5382   Hbase_scannerGet_args() : id(0) {
5383   }
5384 
~Hbase_scannerGet_args()5385   virtual ~Hbase_scannerGet_args() throw() {}
5386 
5387   ScannerID id;
5388 
5389   _Hbase_scannerGet_args__isset __isset;
5390 
__set_id(const ScannerID val)5391   void __set_id(const ScannerID val) {
5392     id = val;
5393   }
5394 
5395   bool operator == (const Hbase_scannerGet_args & rhs) const
5396   {
5397     if (!(id == rhs.id))
5398       return false;
5399     return true;
5400   }
5401   bool operator != (const Hbase_scannerGet_args &rhs) const {
5402     return !(*this == rhs);
5403   }
5404 
5405   bool operator < (const Hbase_scannerGet_args & ) const;
5406 
5407   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
5408   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
5409 
5410 };
5411 
5412 
5413 class Hbase_scannerGet_pargs {
5414  public:
5415 
5416 
~Hbase_scannerGet_pargs()5417   virtual ~Hbase_scannerGet_pargs() throw() {}
5418 
5419   const ScannerID* id;
5420 
5421   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
5422 
5423 };
5424 
5425 typedef struct _Hbase_scannerGet_result__isset {
_Hbase_scannerGet_result__isset_Hbase_scannerGet_result__isset5426   _Hbase_scannerGet_result__isset() : success(false), io(false), ia(false) {}
5427   bool success;
5428   bool io;
5429   bool ia;
5430 } _Hbase_scannerGet_result__isset;
5431 
5432 class Hbase_scannerGet_result {
5433  public:
5434 
Hbase_scannerGet_result()5435   Hbase_scannerGet_result() {
5436   }
5437 
~Hbase_scannerGet_result()5438   virtual ~Hbase_scannerGet_result() throw() {}
5439 
5440   std::vector<TRowResult>  success;
5441   IOError io;
5442   IllegalArgument ia;
5443 
5444   _Hbase_scannerGet_result__isset __isset;
5445 
__set_success(const std::vector<TRowResult> & val)5446   void __set_success(const std::vector<TRowResult> & val) {
5447     success = val;
5448   }
5449 
__set_io(const IOError & val)5450   void __set_io(const IOError& val) {
5451     io = val;
5452   }
5453 
__set_ia(const IllegalArgument & val)5454   void __set_ia(const IllegalArgument& val) {
5455     ia = val;
5456   }
5457 
5458   bool operator == (const Hbase_scannerGet_result & rhs) const
5459   {
5460     if (!(success == rhs.success))
5461       return false;
5462     if (!(io == rhs.io))
5463       return false;
5464     if (!(ia == rhs.ia))
5465       return false;
5466     return true;
5467   }
5468   bool operator != (const Hbase_scannerGet_result &rhs) const {
5469     return !(*this == rhs);
5470   }
5471 
5472   bool operator < (const Hbase_scannerGet_result & ) const;
5473 
5474   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
5475   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
5476 
5477 };
5478 
5479 typedef struct _Hbase_scannerGet_presult__isset {
_Hbase_scannerGet_presult__isset_Hbase_scannerGet_presult__isset5480   _Hbase_scannerGet_presult__isset() : success(false), io(false), ia(false) {}
5481   bool success;
5482   bool io;
5483   bool ia;
5484 } _Hbase_scannerGet_presult__isset;
5485 
5486 class Hbase_scannerGet_presult {
5487  public:
5488 
5489 
~Hbase_scannerGet_presult()5490   virtual ~Hbase_scannerGet_presult() throw() {}
5491 
5492   std::vector<TRowResult> * success;
5493   IOError io;
5494   IllegalArgument ia;
5495 
5496   _Hbase_scannerGet_presult__isset __isset;
5497 
5498   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
5499 
5500 };
5501 
5502 typedef struct _Hbase_scannerGetList_args__isset {
_Hbase_scannerGetList_args__isset_Hbase_scannerGetList_args__isset5503   _Hbase_scannerGetList_args__isset() : id(false), nbRows(false) {}
5504   bool id;
5505   bool nbRows;
5506 } _Hbase_scannerGetList_args__isset;
5507 
5508 class Hbase_scannerGetList_args {
5509  public:
5510 
Hbase_scannerGetList_args()5511   Hbase_scannerGetList_args() : id(0), nbRows(0) {
5512   }
5513 
~Hbase_scannerGetList_args()5514   virtual ~Hbase_scannerGetList_args() throw() {}
5515 
5516   ScannerID id;
5517   int32_t nbRows;
5518 
5519   _Hbase_scannerGetList_args__isset __isset;
5520 
__set_id(const ScannerID val)5521   void __set_id(const ScannerID val) {
5522     id = val;
5523   }
5524 
__set_nbRows(const int32_t val)5525   void __set_nbRows(const int32_t val) {
5526     nbRows = val;
5527   }
5528 
5529   bool operator == (const Hbase_scannerGetList_args & rhs) const
5530   {
5531     if (!(id == rhs.id))
5532       return false;
5533     if (!(nbRows == rhs.nbRows))
5534       return false;
5535     return true;
5536   }
5537   bool operator != (const Hbase_scannerGetList_args &rhs) const {
5538     return !(*this == rhs);
5539   }
5540 
5541   bool operator < (const Hbase_scannerGetList_args & ) const;
5542 
5543   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
5544   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
5545 
5546 };
5547 
5548 
5549 class Hbase_scannerGetList_pargs {
5550  public:
5551 
5552 
~Hbase_scannerGetList_pargs()5553   virtual ~Hbase_scannerGetList_pargs() throw() {}
5554 
5555   const ScannerID* id;
5556   const int32_t* nbRows;
5557 
5558   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
5559 
5560 };
5561 
5562 typedef struct _Hbase_scannerGetList_result__isset {
_Hbase_scannerGetList_result__isset_Hbase_scannerGetList_result__isset5563   _Hbase_scannerGetList_result__isset() : success(false), io(false), ia(false) {}
5564   bool success;
5565   bool io;
5566   bool ia;
5567 } _Hbase_scannerGetList_result__isset;
5568 
5569 class Hbase_scannerGetList_result {
5570  public:
5571 
Hbase_scannerGetList_result()5572   Hbase_scannerGetList_result() {
5573   }
5574 
~Hbase_scannerGetList_result()5575   virtual ~Hbase_scannerGetList_result() throw() {}
5576 
5577   std::vector<TRowResult>  success;
5578   IOError io;
5579   IllegalArgument ia;
5580 
5581   _Hbase_scannerGetList_result__isset __isset;
5582 
__set_success(const std::vector<TRowResult> & val)5583   void __set_success(const std::vector<TRowResult> & val) {
5584     success = val;
5585   }
5586 
__set_io(const IOError & val)5587   void __set_io(const IOError& val) {
5588     io = val;
5589   }
5590 
__set_ia(const IllegalArgument & val)5591   void __set_ia(const IllegalArgument& val) {
5592     ia = val;
5593   }
5594 
5595   bool operator == (const Hbase_scannerGetList_result & rhs) const
5596   {
5597     if (!(success == rhs.success))
5598       return false;
5599     if (!(io == rhs.io))
5600       return false;
5601     if (!(ia == rhs.ia))
5602       return false;
5603     return true;
5604   }
5605   bool operator != (const Hbase_scannerGetList_result &rhs) const {
5606     return !(*this == rhs);
5607   }
5608 
5609   bool operator < (const Hbase_scannerGetList_result & ) const;
5610 
5611   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
5612   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
5613 
5614 };
5615 
5616 typedef struct _Hbase_scannerGetList_presult__isset {
_Hbase_scannerGetList_presult__isset_Hbase_scannerGetList_presult__isset5617   _Hbase_scannerGetList_presult__isset() : success(false), io(false), ia(false) {}
5618   bool success;
5619   bool io;
5620   bool ia;
5621 } _Hbase_scannerGetList_presult__isset;
5622 
5623 class Hbase_scannerGetList_presult {
5624  public:
5625 
5626 
~Hbase_scannerGetList_presult()5627   virtual ~Hbase_scannerGetList_presult() throw() {}
5628 
5629   std::vector<TRowResult> * success;
5630   IOError io;
5631   IllegalArgument ia;
5632 
5633   _Hbase_scannerGetList_presult__isset __isset;
5634 
5635   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
5636 
5637 };
5638 
5639 typedef struct _Hbase_scannerClose_args__isset {
_Hbase_scannerClose_args__isset_Hbase_scannerClose_args__isset5640   _Hbase_scannerClose_args__isset() : id(false) {}
5641   bool id;
5642 } _Hbase_scannerClose_args__isset;
5643 
5644 class Hbase_scannerClose_args {
5645  public:
5646 
Hbase_scannerClose_args()5647   Hbase_scannerClose_args() : id(0) {
5648   }
5649 
~Hbase_scannerClose_args()5650   virtual ~Hbase_scannerClose_args() throw() {}
5651 
5652   ScannerID id;
5653 
5654   _Hbase_scannerClose_args__isset __isset;
5655 
__set_id(const ScannerID val)5656   void __set_id(const ScannerID val) {
5657     id = val;
5658   }
5659 
5660   bool operator == (const Hbase_scannerClose_args & rhs) const
5661   {
5662     if (!(id == rhs.id))
5663       return false;
5664     return true;
5665   }
5666   bool operator != (const Hbase_scannerClose_args &rhs) const {
5667     return !(*this == rhs);
5668   }
5669 
5670   bool operator < (const Hbase_scannerClose_args & ) const;
5671 
5672   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
5673   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
5674 
5675 };
5676 
5677 
5678 class Hbase_scannerClose_pargs {
5679  public:
5680 
5681 
~Hbase_scannerClose_pargs()5682   virtual ~Hbase_scannerClose_pargs() throw() {}
5683 
5684   const ScannerID* id;
5685 
5686   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
5687 
5688 };
5689 
5690 typedef struct _Hbase_scannerClose_result__isset {
_Hbase_scannerClose_result__isset_Hbase_scannerClose_result__isset5691   _Hbase_scannerClose_result__isset() : io(false), ia(false) {}
5692   bool io;
5693   bool ia;
5694 } _Hbase_scannerClose_result__isset;
5695 
5696 class Hbase_scannerClose_result {
5697  public:
5698 
Hbase_scannerClose_result()5699   Hbase_scannerClose_result() {
5700   }
5701 
~Hbase_scannerClose_result()5702   virtual ~Hbase_scannerClose_result() throw() {}
5703 
5704   IOError io;
5705   IllegalArgument ia;
5706 
5707   _Hbase_scannerClose_result__isset __isset;
5708 
__set_io(const IOError & val)5709   void __set_io(const IOError& val) {
5710     io = val;
5711   }
5712 
__set_ia(const IllegalArgument & val)5713   void __set_ia(const IllegalArgument& val) {
5714     ia = val;
5715   }
5716 
5717   bool operator == (const Hbase_scannerClose_result & rhs) const
5718   {
5719     if (!(io == rhs.io))
5720       return false;
5721     if (!(ia == rhs.ia))
5722       return false;
5723     return true;
5724   }
5725   bool operator != (const Hbase_scannerClose_result &rhs) const {
5726     return !(*this == rhs);
5727   }
5728 
5729   bool operator < (const Hbase_scannerClose_result & ) const;
5730 
5731   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
5732   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
5733 
5734 };
5735 
5736 typedef struct _Hbase_scannerClose_presult__isset {
_Hbase_scannerClose_presult__isset_Hbase_scannerClose_presult__isset5737   _Hbase_scannerClose_presult__isset() : io(false), ia(false) {}
5738   bool io;
5739   bool ia;
5740 } _Hbase_scannerClose_presult__isset;
5741 
5742 class Hbase_scannerClose_presult {
5743  public:
5744 
5745 
~Hbase_scannerClose_presult()5746   virtual ~Hbase_scannerClose_presult() throw() {}
5747 
5748   IOError io;
5749   IllegalArgument ia;
5750 
5751   _Hbase_scannerClose_presult__isset __isset;
5752 
5753   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
5754 
5755 };
5756 
5757 typedef struct _Hbase_getRowOrBefore_args__isset {
_Hbase_getRowOrBefore_args__isset_Hbase_getRowOrBefore_args__isset5758   _Hbase_getRowOrBefore_args__isset() : tableName(false), row(false), family(false) {}
5759   bool tableName;
5760   bool row;
5761   bool family;
5762 } _Hbase_getRowOrBefore_args__isset;
5763 
5764 class Hbase_getRowOrBefore_args {
5765  public:
5766 
Hbase_getRowOrBefore_args()5767   Hbase_getRowOrBefore_args() : tableName(), row(), family() {
5768   }
5769 
~Hbase_getRowOrBefore_args()5770   virtual ~Hbase_getRowOrBefore_args() throw() {}
5771 
5772   Text tableName;
5773   Text row;
5774   Text family;
5775 
5776   _Hbase_getRowOrBefore_args__isset __isset;
5777 
__set_tableName(const Text & val)5778   void __set_tableName(const Text& val) {
5779     tableName = val;
5780   }
5781 
__set_row(const Text & val)5782   void __set_row(const Text& val) {
5783     row = val;
5784   }
5785 
__set_family(const Text & val)5786   void __set_family(const Text& val) {
5787     family = val;
5788   }
5789 
5790   bool operator == (const Hbase_getRowOrBefore_args & rhs) const
5791   {
5792     if (!(tableName == rhs.tableName))
5793       return false;
5794     if (!(row == rhs.row))
5795       return false;
5796     if (!(family == rhs.family))
5797       return false;
5798     return true;
5799   }
5800   bool operator != (const Hbase_getRowOrBefore_args &rhs) const {
5801     return !(*this == rhs);
5802   }
5803 
5804   bool operator < (const Hbase_getRowOrBefore_args & ) const;
5805 
5806   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
5807   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
5808 
5809 };
5810 
5811 
5812 class Hbase_getRowOrBefore_pargs {
5813  public:
5814 
5815 
~Hbase_getRowOrBefore_pargs()5816   virtual ~Hbase_getRowOrBefore_pargs() throw() {}
5817 
5818   const Text* tableName;
5819   const Text* row;
5820   const Text* family;
5821 
5822   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
5823 
5824 };
5825 
5826 typedef struct _Hbase_getRowOrBefore_result__isset {
_Hbase_getRowOrBefore_result__isset_Hbase_getRowOrBefore_result__isset5827   _Hbase_getRowOrBefore_result__isset() : success(false), io(false) {}
5828   bool success;
5829   bool io;
5830 } _Hbase_getRowOrBefore_result__isset;
5831 
5832 class Hbase_getRowOrBefore_result {
5833  public:
5834 
Hbase_getRowOrBefore_result()5835   Hbase_getRowOrBefore_result() {
5836   }
5837 
~Hbase_getRowOrBefore_result()5838   virtual ~Hbase_getRowOrBefore_result() throw() {}
5839 
5840   std::vector<TCell>  success;
5841   IOError io;
5842 
5843   _Hbase_getRowOrBefore_result__isset __isset;
5844 
__set_success(const std::vector<TCell> & val)5845   void __set_success(const std::vector<TCell> & val) {
5846     success = val;
5847   }
5848 
__set_io(const IOError & val)5849   void __set_io(const IOError& val) {
5850     io = val;
5851   }
5852 
5853   bool operator == (const Hbase_getRowOrBefore_result & rhs) const
5854   {
5855     if (!(success == rhs.success))
5856       return false;
5857     if (!(io == rhs.io))
5858       return false;
5859     return true;
5860   }
5861   bool operator != (const Hbase_getRowOrBefore_result &rhs) const {
5862     return !(*this == rhs);
5863   }
5864 
5865   bool operator < (const Hbase_getRowOrBefore_result & ) const;
5866 
5867   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
5868   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
5869 
5870 };
5871 
5872 typedef struct _Hbase_getRowOrBefore_presult__isset {
_Hbase_getRowOrBefore_presult__isset_Hbase_getRowOrBefore_presult__isset5873   _Hbase_getRowOrBefore_presult__isset() : success(false), io(false) {}
5874   bool success;
5875   bool io;
5876 } _Hbase_getRowOrBefore_presult__isset;
5877 
5878 class Hbase_getRowOrBefore_presult {
5879  public:
5880 
5881 
~Hbase_getRowOrBefore_presult()5882   virtual ~Hbase_getRowOrBefore_presult() throw() {}
5883 
5884   std::vector<TCell> * success;
5885   IOError io;
5886 
5887   _Hbase_getRowOrBefore_presult__isset __isset;
5888 
5889   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
5890 
5891 };
5892 
5893 typedef struct _Hbase_getRegionInfo_args__isset {
_Hbase_getRegionInfo_args__isset_Hbase_getRegionInfo_args__isset5894   _Hbase_getRegionInfo_args__isset() : row(false) {}
5895   bool row;
5896 } _Hbase_getRegionInfo_args__isset;
5897 
5898 class Hbase_getRegionInfo_args {
5899  public:
5900 
Hbase_getRegionInfo_args()5901   Hbase_getRegionInfo_args() : row() {
5902   }
5903 
~Hbase_getRegionInfo_args()5904   virtual ~Hbase_getRegionInfo_args() throw() {}
5905 
5906   Text row;
5907 
5908   _Hbase_getRegionInfo_args__isset __isset;
5909 
__set_row(const Text & val)5910   void __set_row(const Text& val) {
5911     row = val;
5912   }
5913 
5914   bool operator == (const Hbase_getRegionInfo_args & rhs) const
5915   {
5916     if (!(row == rhs.row))
5917       return false;
5918     return true;
5919   }
5920   bool operator != (const Hbase_getRegionInfo_args &rhs) const {
5921     return !(*this == rhs);
5922   }
5923 
5924   bool operator < (const Hbase_getRegionInfo_args & ) const;
5925 
5926   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
5927   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
5928 
5929 };
5930 
5931 
5932 class Hbase_getRegionInfo_pargs {
5933  public:
5934 
5935 
~Hbase_getRegionInfo_pargs()5936   virtual ~Hbase_getRegionInfo_pargs() throw() {}
5937 
5938   const Text* row;
5939 
5940   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
5941 
5942 };
5943 
5944 typedef struct _Hbase_getRegionInfo_result__isset {
_Hbase_getRegionInfo_result__isset_Hbase_getRegionInfo_result__isset5945   _Hbase_getRegionInfo_result__isset() : success(false), io(false) {}
5946   bool success;
5947   bool io;
5948 } _Hbase_getRegionInfo_result__isset;
5949 
5950 class Hbase_getRegionInfo_result {
5951  public:
5952 
Hbase_getRegionInfo_result()5953   Hbase_getRegionInfo_result() {
5954   }
5955 
~Hbase_getRegionInfo_result()5956   virtual ~Hbase_getRegionInfo_result() throw() {}
5957 
5958   TRegionInfo success;
5959   IOError io;
5960 
5961   _Hbase_getRegionInfo_result__isset __isset;
5962 
__set_success(const TRegionInfo & val)5963   void __set_success(const TRegionInfo& val) {
5964     success = val;
5965   }
5966 
__set_io(const IOError & val)5967   void __set_io(const IOError& val) {
5968     io = val;
5969   }
5970 
5971   bool operator == (const Hbase_getRegionInfo_result & rhs) const
5972   {
5973     if (!(success == rhs.success))
5974       return false;
5975     if (!(io == rhs.io))
5976       return false;
5977     return true;
5978   }
5979   bool operator != (const Hbase_getRegionInfo_result &rhs) const {
5980     return !(*this == rhs);
5981   }
5982 
5983   bool operator < (const Hbase_getRegionInfo_result & ) const;
5984 
5985   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
5986   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
5987 
5988 };
5989 
5990 typedef struct _Hbase_getRegionInfo_presult__isset {
_Hbase_getRegionInfo_presult__isset_Hbase_getRegionInfo_presult__isset5991   _Hbase_getRegionInfo_presult__isset() : success(false), io(false) {}
5992   bool success;
5993   bool io;
5994 } _Hbase_getRegionInfo_presult__isset;
5995 
5996 class Hbase_getRegionInfo_presult {
5997  public:
5998 
5999 
~Hbase_getRegionInfo_presult()6000   virtual ~Hbase_getRegionInfo_presult() throw() {}
6001 
6002   TRegionInfo* success;
6003   IOError io;
6004 
6005   _Hbase_getRegionInfo_presult__isset __isset;
6006 
6007   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
6008 
6009 };
6010 
6011 class HbaseClient : virtual public HbaseIf {
6012  public:
HbaseClient(boost::shared_ptr<::apache::thrift::protocol::TProtocol> prot)6013   HbaseClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) :
6014     piprot_(prot),
6015     poprot_(prot) {
6016     iprot_ = prot.get();
6017     oprot_ = prot.get();
6018   }
HbaseClient(boost::shared_ptr<::apache::thrift::protocol::TProtocol> iprot,boost::shared_ptr<::apache::thrift::protocol::TProtocol> oprot)6019   HbaseClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, boost::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) :
6020     piprot_(iprot),
6021     poprot_(oprot) {
6022     iprot_ = iprot.get();
6023     oprot_ = oprot.get();
6024   }
getInputProtocol()6025   boost::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() {
6026     return piprot_;
6027   }
getOutputProtocol()6028   boost::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() {
6029     return poprot_;
6030   }
6031   void enableTable(const Bytes& tableName);
6032   void send_enableTable(const Bytes& tableName);
6033   void recv_enableTable();
6034   void disableTable(const Bytes& tableName);
6035   void send_disableTable(const Bytes& tableName);
6036   void recv_disableTable();
6037   bool isTableEnabled(const Bytes& tableName);
6038   void send_isTableEnabled(const Bytes& tableName);
6039   bool recv_isTableEnabled();
6040   void compact(const Bytes& tableNameOrRegionName);
6041   void send_compact(const Bytes& tableNameOrRegionName);
6042   void recv_compact();
6043   void majorCompact(const Bytes& tableNameOrRegionName);
6044   void send_majorCompact(const Bytes& tableNameOrRegionName);
6045   void recv_majorCompact();
6046   void getTableNames(std::vector<Text> & _return);
6047   void send_getTableNames();
6048   void recv_getTableNames(std::vector<Text> & _return);
6049   void getColumnDescriptors(std::map<Text, ColumnDescriptor> & _return, const Text& tableName);
6050   void send_getColumnDescriptors(const Text& tableName);
6051   void recv_getColumnDescriptors(std::map<Text, ColumnDescriptor> & _return);
6052   void getTableRegions(std::vector<TRegionInfo> & _return, const Text& tableName);
6053   void send_getTableRegions(const Text& tableName);
6054   void recv_getTableRegions(std::vector<TRegionInfo> & _return);
6055   void createTable(const Text& tableName, const std::vector<ColumnDescriptor> & columnFamilies);
6056   void send_createTable(const Text& tableName, const std::vector<ColumnDescriptor> & columnFamilies);
6057   void recv_createTable();
6058   void deleteTable(const Text& tableName);
6059   void send_deleteTable(const Text& tableName);
6060   void recv_deleteTable();
6061   void get(std::vector<TCell> & _return, const Text& tableName, const Text& row, const Text& column, const std::map<Text, Text> & attributes);
6062   void send_get(const Text& tableName, const Text& row, const Text& column, const std::map<Text, Text> & attributes);
6063   void recv_get(std::vector<TCell> & _return);
6064   void getVer(std::vector<TCell> & _return, const Text& tableName, const Text& row, const Text& column, const int32_t numVersions, const std::map<Text, Text> & attributes);
6065   void send_getVer(const Text& tableName, const Text& row, const Text& column, const int32_t numVersions, const std::map<Text, Text> & attributes);
6066   void recv_getVer(std::vector<TCell> & _return);
6067   void getVerTs(std::vector<TCell> & _return, const Text& tableName, const Text& row, const Text& column, const int64_t timestamp, const int32_t numVersions, const std::map<Text, Text> & attributes);
6068   void send_getVerTs(const Text& tableName, const Text& row, const Text& column, const int64_t timestamp, const int32_t numVersions, const std::map<Text, Text> & attributes);
6069   void recv_getVerTs(std::vector<TCell> & _return);
6070   void getRow(std::vector<TRowResult> & _return, const Text& tableName, const Text& row, const std::map<Text, Text> & attributes);
6071   void send_getRow(const Text& tableName, const Text& row, const std::map<Text, Text> & attributes);
6072   void recv_getRow(std::vector<TRowResult> & _return);
6073   void getRowWithColumns(std::vector<TRowResult> & _return, const Text& tableName, const Text& row, const std::vector<Text> & columns, const std::map<Text, Text> & attributes);
6074   void send_getRowWithColumns(const Text& tableName, const Text& row, const std::vector<Text> & columns, const std::map<Text, Text> & attributes);
6075   void recv_getRowWithColumns(std::vector<TRowResult> & _return);
6076   void getRowTs(std::vector<TRowResult> & _return, const Text& tableName, const Text& row, const int64_t timestamp, const std::map<Text, Text> & attributes);
6077   void send_getRowTs(const Text& tableName, const Text& row, const int64_t timestamp, const std::map<Text, Text> & attributes);
6078   void recv_getRowTs(std::vector<TRowResult> & _return);
6079   void getRowWithColumnsTs(std::vector<TRowResult> & _return, const Text& tableName, const Text& row, const std::vector<Text> & columns, const int64_t timestamp, const std::map<Text, Text> & attributes);
6080   void send_getRowWithColumnsTs(const Text& tableName, const Text& row, const std::vector<Text> & columns, const int64_t timestamp, const std::map<Text, Text> & attributes);
6081   void recv_getRowWithColumnsTs(std::vector<TRowResult> & _return);
6082   void getRows(std::vector<TRowResult> & _return, const Text& tableName, const std::vector<Text> & rows, const std::map<Text, Text> & attributes);
6083   void send_getRows(const Text& tableName, const std::vector<Text> & rows, const std::map<Text, Text> & attributes);
6084   void recv_getRows(std::vector<TRowResult> & _return);
6085   void getRowsWithColumns(std::vector<TRowResult> & _return, const Text& tableName, const std::vector<Text> & rows, const std::vector<Text> & columns, const std::map<Text, Text> & attributes);
6086   void send_getRowsWithColumns(const Text& tableName, const std::vector<Text> & rows, const std::vector<Text> & columns, const std::map<Text, Text> & attributes);
6087   void recv_getRowsWithColumns(std::vector<TRowResult> & _return);
6088   void getRowsTs(std::vector<TRowResult> & _return, const Text& tableName, const std::vector<Text> & rows, const int64_t timestamp, const std::map<Text, Text> & attributes);
6089   void send_getRowsTs(const Text& tableName, const std::vector<Text> & rows, const int64_t timestamp, const std::map<Text, Text> & attributes);
6090   void recv_getRowsTs(std::vector<TRowResult> & _return);
6091   void getRowsWithColumnsTs(std::vector<TRowResult> & _return, const Text& tableName, const std::vector<Text> & rows, const std::vector<Text> & columns, const int64_t timestamp, const std::map<Text, Text> & attributes);
6092   void send_getRowsWithColumnsTs(const Text& tableName, const std::vector<Text> & rows, const std::vector<Text> & columns, const int64_t timestamp, const std::map<Text, Text> & attributes);
6093   void recv_getRowsWithColumnsTs(std::vector<TRowResult> & _return);
6094   void mutateRow(const Text& tableName, const Text& row, const std::vector<Mutation> & mutations, const std::map<Text, Text> & attributes);
6095   void send_mutateRow(const Text& tableName, const Text& row, const std::vector<Mutation> & mutations, const std::map<Text, Text> & attributes);
6096   void recv_mutateRow();
6097   void mutateRowTs(const Text& tableName, const Text& row, const std::vector<Mutation> & mutations, const int64_t timestamp, const std::map<Text, Text> & attributes);
6098   void send_mutateRowTs(const Text& tableName, const Text& row, const std::vector<Mutation> & mutations, const int64_t timestamp, const std::map<Text, Text> & attributes);
6099   void recv_mutateRowTs();
6100   void mutateRows(const Text& tableName, const std::vector<BatchMutation> & rowBatches, const std::map<Text, Text> & attributes);
6101   void send_mutateRows(const Text& tableName, const std::vector<BatchMutation> & rowBatches, const std::map<Text, Text> & attributes);
6102   void recv_mutateRows();
6103   void mutateRowsTs(const Text& tableName, const std::vector<BatchMutation> & rowBatches, const int64_t timestamp, const std::map<Text, Text> & attributes);
6104   void send_mutateRowsTs(const Text& tableName, const std::vector<BatchMutation> & rowBatches, const int64_t timestamp, const std::map<Text, Text> & attributes);
6105   void recv_mutateRowsTs();
6106   int64_t atomicIncrement(const Text& tableName, const Text& row, const Text& column, const int64_t value);
6107   void send_atomicIncrement(const Text& tableName, const Text& row, const Text& column, const int64_t value);
6108   int64_t recv_atomicIncrement();
6109   void deleteAll(const Text& tableName, const Text& row, const Text& column, const std::map<Text, Text> & attributes);
6110   void send_deleteAll(const Text& tableName, const Text& row, const Text& column, const std::map<Text, Text> & attributes);
6111   void recv_deleteAll();
6112   void deleteAllTs(const Text& tableName, const Text& row, const Text& column, const int64_t timestamp, const std::map<Text, Text> & attributes);
6113   void send_deleteAllTs(const Text& tableName, const Text& row, const Text& column, const int64_t timestamp, const std::map<Text, Text> & attributes);
6114   void recv_deleteAllTs();
6115   void deleteAllRow(const Text& tableName, const Text& row, const std::map<Text, Text> & attributes);
6116   void send_deleteAllRow(const Text& tableName, const Text& row, const std::map<Text, Text> & attributes);
6117   void recv_deleteAllRow();
6118   void increment(const TIncrement& increment);
6119   void send_increment(const TIncrement& increment);
6120   void recv_increment();
6121   void incrementRows(const std::vector<TIncrement> & increments);
6122   void send_incrementRows(const std::vector<TIncrement> & increments);
6123   void recv_incrementRows();
6124   void deleteAllRowTs(const Text& tableName, const Text& row, const int64_t timestamp, const std::map<Text, Text> & attributes);
6125   void send_deleteAllRowTs(const Text& tableName, const Text& row, const int64_t timestamp, const std::map<Text, Text> & attributes);
6126   void recv_deleteAllRowTs();
6127   ScannerID scannerOpenWithScan(const Text& tableName, const TScan& scan, const std::map<Text, Text> & attributes);
6128   void send_scannerOpenWithScan(const Text& tableName, const TScan& scan, const std::map<Text, Text> & attributes);
6129   ScannerID recv_scannerOpenWithScan();
6130   ScannerID scannerOpen(const Text& tableName, const Text& startRow, const std::vector<Text> & columns, const std::map<Text, Text> & attributes);
6131   void send_scannerOpen(const Text& tableName, const Text& startRow, const std::vector<Text> & columns, const std::map<Text, Text> & attributes);
6132   ScannerID recv_scannerOpen();
6133   ScannerID scannerOpenWithStop(const Text& tableName, const Text& startRow, const Text& stopRow, const std::vector<Text> & columns, const std::map<Text, Text> & attributes);
6134   void send_scannerOpenWithStop(const Text& tableName, const Text& startRow, const Text& stopRow, const std::vector<Text> & columns, const std::map<Text, Text> & attributes);
6135   ScannerID recv_scannerOpenWithStop();
6136   ScannerID scannerOpenWithPrefix(const Text& tableName, const Text& startAndPrefix, const std::vector<Text> & columns, const std::map<Text, Text> & attributes);
6137   void send_scannerOpenWithPrefix(const Text& tableName, const Text& startAndPrefix, const std::vector<Text> & columns, const std::map<Text, Text> & attributes);
6138   ScannerID recv_scannerOpenWithPrefix();
6139   ScannerID scannerOpenTs(const Text& tableName, const Text& startRow, const std::vector<Text> & columns, const int64_t timestamp, const std::map<Text, Text> & attributes);
6140   void send_scannerOpenTs(const Text& tableName, const Text& startRow, const std::vector<Text> & columns, const int64_t timestamp, const std::map<Text, Text> & attributes);
6141   ScannerID recv_scannerOpenTs();
6142   ScannerID scannerOpenWithStopTs(const Text& tableName, const Text& startRow, const Text& stopRow, const std::vector<Text> & columns, const int64_t timestamp, const std::map<Text, Text> & attributes);
6143   void send_scannerOpenWithStopTs(const Text& tableName, const Text& startRow, const Text& stopRow, const std::vector<Text> & columns, const int64_t timestamp, const std::map<Text, Text> & attributes);
6144   ScannerID recv_scannerOpenWithStopTs();
6145   void scannerGet(std::vector<TRowResult> & _return, const ScannerID id);
6146   void send_scannerGet(const ScannerID id);
6147   void recv_scannerGet(std::vector<TRowResult> & _return);
6148   void scannerGetList(std::vector<TRowResult> & _return, const ScannerID id, const int32_t nbRows);
6149   void send_scannerGetList(const ScannerID id, const int32_t nbRows);
6150   void recv_scannerGetList(std::vector<TRowResult> & _return);
6151   void scannerClose(const ScannerID id);
6152   void send_scannerClose(const ScannerID id);
6153   void recv_scannerClose();
6154   void getRowOrBefore(std::vector<TCell> & _return, const Text& tableName, const Text& row, const Text& family);
6155   void send_getRowOrBefore(const Text& tableName, const Text& row, const Text& family);
6156   void recv_getRowOrBefore(std::vector<TCell> & _return);
6157   void getRegionInfo(TRegionInfo& _return, const Text& row);
6158   void send_getRegionInfo(const Text& row);
6159   void recv_getRegionInfo(TRegionInfo& _return);
6160  protected:
6161   boost::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_;
6162   boost::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_;
6163   ::apache::thrift::protocol::TProtocol* iprot_;
6164   ::apache::thrift::protocol::TProtocol* oprot_;
6165 };
6166 
6167 class HbaseProcessor : public ::apache::thrift::TDispatchProcessor {
6168  protected:
6169   boost::shared_ptr<HbaseIf> iface_;
6170   virtual bool dispatchCall(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, const std::string& fname, int32_t seqid, void* callContext);
6171  private:
6172   typedef  void (HbaseProcessor::*ProcessFunction)(int32_t, ::apache::thrift::protocol::TProtocol*, ::apache::thrift::protocol::TProtocol*, void*);
6173   typedef std::map<std::string, ProcessFunction> ProcessMap;
6174   ProcessMap processMap_;
6175   void process_enableTable(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6176   void process_disableTable(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6177   void process_isTableEnabled(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6178   void process_compact(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6179   void process_majorCompact(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6180   void process_getTableNames(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6181   void process_getColumnDescriptors(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6182   void process_getTableRegions(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6183   void process_createTable(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6184   void process_deleteTable(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6185   void process_get(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6186   void process_getVer(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6187   void process_getVerTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6188   void process_getRow(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6189   void process_getRowWithColumns(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6190   void process_getRowTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6191   void process_getRowWithColumnsTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6192   void process_getRows(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6193   void process_getRowsWithColumns(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6194   void process_getRowsTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6195   void process_getRowsWithColumnsTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6196   void process_mutateRow(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6197   void process_mutateRowTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6198   void process_mutateRows(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6199   void process_mutateRowsTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6200   void process_atomicIncrement(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6201   void process_deleteAll(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6202   void process_deleteAllTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6203   void process_deleteAllRow(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6204   void process_increment(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6205   void process_incrementRows(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6206   void process_deleteAllRowTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6207   void process_scannerOpenWithScan(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6208   void process_scannerOpen(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6209   void process_scannerOpenWithStop(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6210   void process_scannerOpenWithPrefix(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6211   void process_scannerOpenTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6212   void process_scannerOpenWithStopTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6213   void process_scannerGet(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6214   void process_scannerGetList(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6215   void process_scannerClose(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6216   void process_getRowOrBefore(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6217   void process_getRegionInfo(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
6218  public:
HbaseProcessor(boost::shared_ptr<HbaseIf> iface)6219   HbaseProcessor(boost::shared_ptr<HbaseIf> iface) :
6220     iface_(iface) {
6221     processMap_["enableTable"] = &HbaseProcessor::process_enableTable;
6222     processMap_["disableTable"] = &HbaseProcessor::process_disableTable;
6223     processMap_["isTableEnabled"] = &HbaseProcessor::process_isTableEnabled;
6224     processMap_["compact"] = &HbaseProcessor::process_compact;
6225     processMap_["majorCompact"] = &HbaseProcessor::process_majorCompact;
6226     processMap_["getTableNames"] = &HbaseProcessor::process_getTableNames;
6227     processMap_["getColumnDescriptors"] = &HbaseProcessor::process_getColumnDescriptors;
6228     processMap_["getTableRegions"] = &HbaseProcessor::process_getTableRegions;
6229     processMap_["createTable"] = &HbaseProcessor::process_createTable;
6230     processMap_["deleteTable"] = &HbaseProcessor::process_deleteTable;
6231     processMap_["get"] = &HbaseProcessor::process_get;
6232     processMap_["getVer"] = &HbaseProcessor::process_getVer;
6233     processMap_["getVerTs"] = &HbaseProcessor::process_getVerTs;
6234     processMap_["getRow"] = &HbaseProcessor::process_getRow;
6235     processMap_["getRowWithColumns"] = &HbaseProcessor::process_getRowWithColumns;
6236     processMap_["getRowTs"] = &HbaseProcessor::process_getRowTs;
6237     processMap_["getRowWithColumnsTs"] = &HbaseProcessor::process_getRowWithColumnsTs;
6238     processMap_["getRows"] = &HbaseProcessor::process_getRows;
6239     processMap_["getRowsWithColumns"] = &HbaseProcessor::process_getRowsWithColumns;
6240     processMap_["getRowsTs"] = &HbaseProcessor::process_getRowsTs;
6241     processMap_["getRowsWithColumnsTs"] = &HbaseProcessor::process_getRowsWithColumnsTs;
6242     processMap_["mutateRow"] = &HbaseProcessor::process_mutateRow;
6243     processMap_["mutateRowTs"] = &HbaseProcessor::process_mutateRowTs;
6244     processMap_["mutateRows"] = &HbaseProcessor::process_mutateRows;
6245     processMap_["mutateRowsTs"] = &HbaseProcessor::process_mutateRowsTs;
6246     processMap_["atomicIncrement"] = &HbaseProcessor::process_atomicIncrement;
6247     processMap_["deleteAll"] = &HbaseProcessor::process_deleteAll;
6248     processMap_["deleteAllTs"] = &HbaseProcessor::process_deleteAllTs;
6249     processMap_["deleteAllRow"] = &HbaseProcessor::process_deleteAllRow;
6250     processMap_["increment"] = &HbaseProcessor::process_increment;
6251     processMap_["incrementRows"] = &HbaseProcessor::process_incrementRows;
6252     processMap_["deleteAllRowTs"] = &HbaseProcessor::process_deleteAllRowTs;
6253     processMap_["scannerOpenWithScan"] = &HbaseProcessor::process_scannerOpenWithScan;
6254     processMap_["scannerOpen"] = &HbaseProcessor::process_scannerOpen;
6255     processMap_["scannerOpenWithStop"] = &HbaseProcessor::process_scannerOpenWithStop;
6256     processMap_["scannerOpenWithPrefix"] = &HbaseProcessor::process_scannerOpenWithPrefix;
6257     processMap_["scannerOpenTs"] = &HbaseProcessor::process_scannerOpenTs;
6258     processMap_["scannerOpenWithStopTs"] = &HbaseProcessor::process_scannerOpenWithStopTs;
6259     processMap_["scannerGet"] = &HbaseProcessor::process_scannerGet;
6260     processMap_["scannerGetList"] = &HbaseProcessor::process_scannerGetList;
6261     processMap_["scannerClose"] = &HbaseProcessor::process_scannerClose;
6262     processMap_["getRowOrBefore"] = &HbaseProcessor::process_getRowOrBefore;
6263     processMap_["getRegionInfo"] = &HbaseProcessor::process_getRegionInfo;
6264   }
6265 
~HbaseProcessor()6266   virtual ~HbaseProcessor() {}
6267 };
6268 
6269 class HbaseProcessorFactory : public ::apache::thrift::TProcessorFactory {
6270  public:
HbaseProcessorFactory(const::boost::shared_ptr<HbaseIfFactory> & handlerFactory)6271   HbaseProcessorFactory(const ::boost::shared_ptr< HbaseIfFactory >& handlerFactory) :
6272       handlerFactory_(handlerFactory) {}
6273 
6274   ::boost::shared_ptr< ::apache::thrift::TProcessor > getProcessor(const ::apache::thrift::TConnectionInfo& connInfo);
6275 
6276  protected:
6277   ::boost::shared_ptr< HbaseIfFactory > handlerFactory_;
6278 };
6279 
6280 class HbaseMultiface : virtual public HbaseIf {
6281  public:
HbaseMultiface(std::vector<boost::shared_ptr<HbaseIf>> & ifaces)6282   HbaseMultiface(std::vector<boost::shared_ptr<HbaseIf> >& ifaces) : ifaces_(ifaces) {
6283   }
~HbaseMultiface()6284   virtual ~HbaseMultiface() {}
6285  protected:
6286   std::vector<boost::shared_ptr<HbaseIf> > ifaces_;
HbaseMultiface()6287   HbaseMultiface() {}
add(boost::shared_ptr<HbaseIf> iface)6288   void add(boost::shared_ptr<HbaseIf> iface) {
6289     ifaces_.push_back(iface);
6290   }
6291  public:
enableTable(const Bytes & tableName)6292   void enableTable(const Bytes& tableName) {
6293     size_t sz = ifaces_.size();
6294     size_t i = 0;
6295     for (; i < (sz - 1); ++i) {
6296       ifaces_[i]->enableTable(tableName);
6297     }
6298     ifaces_[i]->enableTable(tableName);
6299   }
6300 
disableTable(const Bytes & tableName)6301   void disableTable(const Bytes& tableName) {
6302     size_t sz = ifaces_.size();
6303     size_t i = 0;
6304     for (; i < (sz - 1); ++i) {
6305       ifaces_[i]->disableTable(tableName);
6306     }
6307     ifaces_[i]->disableTable(tableName);
6308   }
6309 
isTableEnabled(const Bytes & tableName)6310   bool isTableEnabled(const Bytes& tableName) {
6311     size_t sz = ifaces_.size();
6312     size_t i = 0;
6313     for (; i < (sz - 1); ++i) {
6314       ifaces_[i]->isTableEnabled(tableName);
6315     }
6316     return ifaces_[i]->isTableEnabled(tableName);
6317   }
6318 
compact(const Bytes & tableNameOrRegionName)6319   void compact(const Bytes& tableNameOrRegionName) {
6320     size_t sz = ifaces_.size();
6321     size_t i = 0;
6322     for (; i < (sz - 1); ++i) {
6323       ifaces_[i]->compact(tableNameOrRegionName);
6324     }
6325     ifaces_[i]->compact(tableNameOrRegionName);
6326   }
6327 
majorCompact(const Bytes & tableNameOrRegionName)6328   void majorCompact(const Bytes& tableNameOrRegionName) {
6329     size_t sz = ifaces_.size();
6330     size_t i = 0;
6331     for (; i < (sz - 1); ++i) {
6332       ifaces_[i]->majorCompact(tableNameOrRegionName);
6333     }
6334     ifaces_[i]->majorCompact(tableNameOrRegionName);
6335   }
6336 
getTableNames(std::vector<Text> & _return)6337   void getTableNames(std::vector<Text> & _return) {
6338     size_t sz = ifaces_.size();
6339     size_t i = 0;
6340     for (; i < (sz - 1); ++i) {
6341       ifaces_[i]->getTableNames(_return);
6342     }
6343     ifaces_[i]->getTableNames(_return);
6344     return;
6345   }
6346 
getColumnDescriptors(std::map<Text,ColumnDescriptor> & _return,const Text & tableName)6347   void getColumnDescriptors(std::map<Text, ColumnDescriptor> & _return, const Text& tableName) {
6348     size_t sz = ifaces_.size();
6349     size_t i = 0;
6350     for (; i < (sz - 1); ++i) {
6351       ifaces_[i]->getColumnDescriptors(_return, tableName);
6352     }
6353     ifaces_[i]->getColumnDescriptors(_return, tableName);
6354     return;
6355   }
6356 
getTableRegions(std::vector<TRegionInfo> & _return,const Text & tableName)6357   void getTableRegions(std::vector<TRegionInfo> & _return, const Text& tableName) {
6358     size_t sz = ifaces_.size();
6359     size_t i = 0;
6360     for (; i < (sz - 1); ++i) {
6361       ifaces_[i]->getTableRegions(_return, tableName);
6362     }
6363     ifaces_[i]->getTableRegions(_return, tableName);
6364     return;
6365   }
6366 
createTable(const Text & tableName,const std::vector<ColumnDescriptor> & columnFamilies)6367   void createTable(const Text& tableName, const std::vector<ColumnDescriptor> & columnFamilies) {
6368     size_t sz = ifaces_.size();
6369     size_t i = 0;
6370     for (; i < (sz - 1); ++i) {
6371       ifaces_[i]->createTable(tableName, columnFamilies);
6372     }
6373     ifaces_[i]->createTable(tableName, columnFamilies);
6374   }
6375 
deleteTable(const Text & tableName)6376   void deleteTable(const Text& tableName) {
6377     size_t sz = ifaces_.size();
6378     size_t i = 0;
6379     for (; i < (sz - 1); ++i) {
6380       ifaces_[i]->deleteTable(tableName);
6381     }
6382     ifaces_[i]->deleteTable(tableName);
6383   }
6384 
get(std::vector<TCell> & _return,const Text & tableName,const Text & row,const Text & column,const std::map<Text,Text> & attributes)6385   void get(std::vector<TCell> & _return, const Text& tableName, const Text& row, const Text& column, const std::map<Text, Text> & attributes) {
6386     size_t sz = ifaces_.size();
6387     size_t i = 0;
6388     for (; i < (sz - 1); ++i) {
6389       ifaces_[i]->get(_return, tableName, row, column, attributes);
6390     }
6391     ifaces_[i]->get(_return, tableName, row, column, attributes);
6392     return;
6393   }
6394 
getVer(std::vector<TCell> & _return,const Text & tableName,const Text & row,const Text & column,const int32_t numVersions,const std::map<Text,Text> & attributes)6395   void getVer(std::vector<TCell> & _return, const Text& tableName, const Text& row, const Text& column, const int32_t numVersions, const std::map<Text, Text> & attributes) {
6396     size_t sz = ifaces_.size();
6397     size_t i = 0;
6398     for (; i < (sz - 1); ++i) {
6399       ifaces_[i]->getVer(_return, tableName, row, column, numVersions, attributes);
6400     }
6401     ifaces_[i]->getVer(_return, tableName, row, column, numVersions, attributes);
6402     return;
6403   }
6404 
getVerTs(std::vector<TCell> & _return,const Text & tableName,const Text & row,const Text & column,const int64_t timestamp,const int32_t numVersions,const std::map<Text,Text> & attributes)6405   void getVerTs(std::vector<TCell> & _return, const Text& tableName, const Text& row, const Text& column, const int64_t timestamp, const int32_t numVersions, const std::map<Text, Text> & attributes) {
6406     size_t sz = ifaces_.size();
6407     size_t i = 0;
6408     for (; i < (sz - 1); ++i) {
6409       ifaces_[i]->getVerTs(_return, tableName, row, column, timestamp, numVersions, attributes);
6410     }
6411     ifaces_[i]->getVerTs(_return, tableName, row, column, timestamp, numVersions, attributes);
6412     return;
6413   }
6414 
getRow(std::vector<TRowResult> & _return,const Text & tableName,const Text & row,const std::map<Text,Text> & attributes)6415   void getRow(std::vector<TRowResult> & _return, const Text& tableName, const Text& row, const std::map<Text, Text> & attributes) {
6416     size_t sz = ifaces_.size();
6417     size_t i = 0;
6418     for (; i < (sz - 1); ++i) {
6419       ifaces_[i]->getRow(_return, tableName, row, attributes);
6420     }
6421     ifaces_[i]->getRow(_return, tableName, row, attributes);
6422     return;
6423   }
6424 
getRowWithColumns(std::vector<TRowResult> & _return,const Text & tableName,const Text & row,const std::vector<Text> & columns,const std::map<Text,Text> & attributes)6425   void getRowWithColumns(std::vector<TRowResult> & _return, const Text& tableName, const Text& row, const std::vector<Text> & columns, const std::map<Text, Text> & attributes) {
6426     size_t sz = ifaces_.size();
6427     size_t i = 0;
6428     for (; i < (sz - 1); ++i) {
6429       ifaces_[i]->getRowWithColumns(_return, tableName, row, columns, attributes);
6430     }
6431     ifaces_[i]->getRowWithColumns(_return, tableName, row, columns, attributes);
6432     return;
6433   }
6434 
getRowTs(std::vector<TRowResult> & _return,const Text & tableName,const Text & row,const int64_t timestamp,const std::map<Text,Text> & attributes)6435   void getRowTs(std::vector<TRowResult> & _return, const Text& tableName, const Text& row, const int64_t timestamp, const std::map<Text, Text> & attributes) {
6436     size_t sz = ifaces_.size();
6437     size_t i = 0;
6438     for (; i < (sz - 1); ++i) {
6439       ifaces_[i]->getRowTs(_return, tableName, row, timestamp, attributes);
6440     }
6441     ifaces_[i]->getRowTs(_return, tableName, row, timestamp, attributes);
6442     return;
6443   }
6444 
getRowWithColumnsTs(std::vector<TRowResult> & _return,const Text & tableName,const Text & row,const std::vector<Text> & columns,const int64_t timestamp,const std::map<Text,Text> & attributes)6445   void getRowWithColumnsTs(std::vector<TRowResult> & _return, const Text& tableName, const Text& row, const std::vector<Text> & columns, const int64_t timestamp, const std::map<Text, Text> & attributes) {
6446     size_t sz = ifaces_.size();
6447     size_t i = 0;
6448     for (; i < (sz - 1); ++i) {
6449       ifaces_[i]->getRowWithColumnsTs(_return, tableName, row, columns, timestamp, attributes);
6450     }
6451     ifaces_[i]->getRowWithColumnsTs(_return, tableName, row, columns, timestamp, attributes);
6452     return;
6453   }
6454 
getRows(std::vector<TRowResult> & _return,const Text & tableName,const std::vector<Text> & rows,const std::map<Text,Text> & attributes)6455   void getRows(std::vector<TRowResult> & _return, const Text& tableName, const std::vector<Text> & rows, const std::map<Text, Text> & attributes) {
6456     size_t sz = ifaces_.size();
6457     size_t i = 0;
6458     for (; i < (sz - 1); ++i) {
6459       ifaces_[i]->getRows(_return, tableName, rows, attributes);
6460     }
6461     ifaces_[i]->getRows(_return, tableName, rows, attributes);
6462     return;
6463   }
6464 
getRowsWithColumns(std::vector<TRowResult> & _return,const Text & tableName,const std::vector<Text> & rows,const std::vector<Text> & columns,const std::map<Text,Text> & attributes)6465   void getRowsWithColumns(std::vector<TRowResult> & _return, const Text& tableName, const std::vector<Text> & rows, const std::vector<Text> & columns, const std::map<Text, Text> & attributes) {
6466     size_t sz = ifaces_.size();
6467     size_t i = 0;
6468     for (; i < (sz - 1); ++i) {
6469       ifaces_[i]->getRowsWithColumns(_return, tableName, rows, columns, attributes);
6470     }
6471     ifaces_[i]->getRowsWithColumns(_return, tableName, rows, columns, attributes);
6472     return;
6473   }
6474 
getRowsTs(std::vector<TRowResult> & _return,const Text & tableName,const std::vector<Text> & rows,const int64_t timestamp,const std::map<Text,Text> & attributes)6475   void getRowsTs(std::vector<TRowResult> & _return, const Text& tableName, const std::vector<Text> & rows, const int64_t timestamp, const std::map<Text, Text> & attributes) {
6476     size_t sz = ifaces_.size();
6477     size_t i = 0;
6478     for (; i < (sz - 1); ++i) {
6479       ifaces_[i]->getRowsTs(_return, tableName, rows, timestamp, attributes);
6480     }
6481     ifaces_[i]->getRowsTs(_return, tableName, rows, timestamp, attributes);
6482     return;
6483   }
6484 
getRowsWithColumnsTs(std::vector<TRowResult> & _return,const Text & tableName,const std::vector<Text> & rows,const std::vector<Text> & columns,const int64_t timestamp,const std::map<Text,Text> & attributes)6485   void getRowsWithColumnsTs(std::vector<TRowResult> & _return, const Text& tableName, const std::vector<Text> & rows, const std::vector<Text> & columns, const int64_t timestamp, const std::map<Text, Text> & attributes) {
6486     size_t sz = ifaces_.size();
6487     size_t i = 0;
6488     for (; i < (sz - 1); ++i) {
6489       ifaces_[i]->getRowsWithColumnsTs(_return, tableName, rows, columns, timestamp, attributes);
6490     }
6491     ifaces_[i]->getRowsWithColumnsTs(_return, tableName, rows, columns, timestamp, attributes);
6492     return;
6493   }
6494 
mutateRow(const Text & tableName,const Text & row,const std::vector<Mutation> & mutations,const std::map<Text,Text> & attributes)6495   void mutateRow(const Text& tableName, const Text& row, const std::vector<Mutation> & mutations, const std::map<Text, Text> & attributes) {
6496     size_t sz = ifaces_.size();
6497     size_t i = 0;
6498     for (; i < (sz - 1); ++i) {
6499       ifaces_[i]->mutateRow(tableName, row, mutations, attributes);
6500     }
6501     ifaces_[i]->mutateRow(tableName, row, mutations, attributes);
6502   }
6503 
mutateRowTs(const Text & tableName,const Text & row,const std::vector<Mutation> & mutations,const int64_t timestamp,const std::map<Text,Text> & attributes)6504   void mutateRowTs(const Text& tableName, const Text& row, const std::vector<Mutation> & mutations, const int64_t timestamp, const std::map<Text, Text> & attributes) {
6505     size_t sz = ifaces_.size();
6506     size_t i = 0;
6507     for (; i < (sz - 1); ++i) {
6508       ifaces_[i]->mutateRowTs(tableName, row, mutations, timestamp, attributes);
6509     }
6510     ifaces_[i]->mutateRowTs(tableName, row, mutations, timestamp, attributes);
6511   }
6512 
mutateRows(const Text & tableName,const std::vector<BatchMutation> & rowBatches,const std::map<Text,Text> & attributes)6513   void mutateRows(const Text& tableName, const std::vector<BatchMutation> & rowBatches, const std::map<Text, Text> & attributes) {
6514     size_t sz = ifaces_.size();
6515     size_t i = 0;
6516     for (; i < (sz - 1); ++i) {
6517       ifaces_[i]->mutateRows(tableName, rowBatches, attributes);
6518     }
6519     ifaces_[i]->mutateRows(tableName, rowBatches, attributes);
6520   }
6521 
mutateRowsTs(const Text & tableName,const std::vector<BatchMutation> & rowBatches,const int64_t timestamp,const std::map<Text,Text> & attributes)6522   void mutateRowsTs(const Text& tableName, const std::vector<BatchMutation> & rowBatches, const int64_t timestamp, const std::map<Text, Text> & attributes) {
6523     size_t sz = ifaces_.size();
6524     size_t i = 0;
6525     for (; i < (sz - 1); ++i) {
6526       ifaces_[i]->mutateRowsTs(tableName, rowBatches, timestamp, attributes);
6527     }
6528     ifaces_[i]->mutateRowsTs(tableName, rowBatches, timestamp, attributes);
6529   }
6530 
atomicIncrement(const Text & tableName,const Text & row,const Text & column,const int64_t value)6531   int64_t atomicIncrement(const Text& tableName, const Text& row, const Text& column, const int64_t value) {
6532     size_t sz = ifaces_.size();
6533     size_t i = 0;
6534     for (; i < (sz - 1); ++i) {
6535       ifaces_[i]->atomicIncrement(tableName, row, column, value);
6536     }
6537     return ifaces_[i]->atomicIncrement(tableName, row, column, value);
6538   }
6539 
deleteAll(const Text & tableName,const Text & row,const Text & column,const std::map<Text,Text> & attributes)6540   void deleteAll(const Text& tableName, const Text& row, const Text& column, const std::map<Text, Text> & attributes) {
6541     size_t sz = ifaces_.size();
6542     size_t i = 0;
6543     for (; i < (sz - 1); ++i) {
6544       ifaces_[i]->deleteAll(tableName, row, column, attributes);
6545     }
6546     ifaces_[i]->deleteAll(tableName, row, column, attributes);
6547   }
6548 
deleteAllTs(const Text & tableName,const Text & row,const Text & column,const int64_t timestamp,const std::map<Text,Text> & attributes)6549   void deleteAllTs(const Text& tableName, const Text& row, const Text& column, const int64_t timestamp, const std::map<Text, Text> & attributes) {
6550     size_t sz = ifaces_.size();
6551     size_t i = 0;
6552     for (; i < (sz - 1); ++i) {
6553       ifaces_[i]->deleteAllTs(tableName, row, column, timestamp, attributes);
6554     }
6555     ifaces_[i]->deleteAllTs(tableName, row, column, timestamp, attributes);
6556   }
6557 
deleteAllRow(const Text & tableName,const Text & row,const std::map<Text,Text> & attributes)6558   void deleteAllRow(const Text& tableName, const Text& row, const std::map<Text, Text> & attributes) {
6559     size_t sz = ifaces_.size();
6560     size_t i = 0;
6561     for (; i < (sz - 1); ++i) {
6562       ifaces_[i]->deleteAllRow(tableName, row, attributes);
6563     }
6564     ifaces_[i]->deleteAllRow(tableName, row, attributes);
6565   }
6566 
increment(const TIncrement & increment)6567   void increment(const TIncrement& increment) {
6568     size_t sz = ifaces_.size();
6569     size_t i = 0;
6570     for (; i < (sz - 1); ++i) {
6571       ifaces_[i]->increment(increment);
6572     }
6573     ifaces_[i]->increment(increment);
6574   }
6575 
incrementRows(const std::vector<TIncrement> & increments)6576   void incrementRows(const std::vector<TIncrement> & increments) {
6577     size_t sz = ifaces_.size();
6578     size_t i = 0;
6579     for (; i < (sz - 1); ++i) {
6580       ifaces_[i]->incrementRows(increments);
6581     }
6582     ifaces_[i]->incrementRows(increments);
6583   }
6584 
deleteAllRowTs(const Text & tableName,const Text & row,const int64_t timestamp,const std::map<Text,Text> & attributes)6585   void deleteAllRowTs(const Text& tableName, const Text& row, const int64_t timestamp, const std::map<Text, Text> & attributes) {
6586     size_t sz = ifaces_.size();
6587     size_t i = 0;
6588     for (; i < (sz - 1); ++i) {
6589       ifaces_[i]->deleteAllRowTs(tableName, row, timestamp, attributes);
6590     }
6591     ifaces_[i]->deleteAllRowTs(tableName, row, timestamp, attributes);
6592   }
6593 
scannerOpenWithScan(const Text & tableName,const TScan & scan,const std::map<Text,Text> & attributes)6594   ScannerID scannerOpenWithScan(const Text& tableName, const TScan& scan, const std::map<Text, Text> & attributes) {
6595     size_t sz = ifaces_.size();
6596     size_t i = 0;
6597     for (; i < (sz - 1); ++i) {
6598       ifaces_[i]->scannerOpenWithScan(tableName, scan, attributes);
6599     }
6600     return ifaces_[i]->scannerOpenWithScan(tableName, scan, attributes);
6601   }
6602 
scannerOpen(const Text & tableName,const Text & startRow,const std::vector<Text> & columns,const std::map<Text,Text> & attributes)6603   ScannerID scannerOpen(const Text& tableName, const Text& startRow, const std::vector<Text> & columns, const std::map<Text, Text> & attributes) {
6604     size_t sz = ifaces_.size();
6605     size_t i = 0;
6606     for (; i < (sz - 1); ++i) {
6607       ifaces_[i]->scannerOpen(tableName, startRow, columns, attributes);
6608     }
6609     return ifaces_[i]->scannerOpen(tableName, startRow, columns, attributes);
6610   }
6611 
scannerOpenWithStop(const Text & tableName,const Text & startRow,const Text & stopRow,const std::vector<Text> & columns,const std::map<Text,Text> & attributes)6612   ScannerID scannerOpenWithStop(const Text& tableName, const Text& startRow, const Text& stopRow, const std::vector<Text> & columns, const std::map<Text, Text> & attributes) {
6613     size_t sz = ifaces_.size();
6614     size_t i = 0;
6615     for (; i < (sz - 1); ++i) {
6616       ifaces_[i]->scannerOpenWithStop(tableName, startRow, stopRow, columns, attributes);
6617     }
6618     return ifaces_[i]->scannerOpenWithStop(tableName, startRow, stopRow, columns, attributes);
6619   }
6620 
scannerOpenWithPrefix(const Text & tableName,const Text & startAndPrefix,const std::vector<Text> & columns,const std::map<Text,Text> & attributes)6621   ScannerID scannerOpenWithPrefix(const Text& tableName, const Text& startAndPrefix, const std::vector<Text> & columns, const std::map<Text, Text> & attributes) {
6622     size_t sz = ifaces_.size();
6623     size_t i = 0;
6624     for (; i < (sz - 1); ++i) {
6625       ifaces_[i]->scannerOpenWithPrefix(tableName, startAndPrefix, columns, attributes);
6626     }
6627     return ifaces_[i]->scannerOpenWithPrefix(tableName, startAndPrefix, columns, attributes);
6628   }
6629 
scannerOpenTs(const Text & tableName,const Text & startRow,const std::vector<Text> & columns,const int64_t timestamp,const std::map<Text,Text> & attributes)6630   ScannerID scannerOpenTs(const Text& tableName, const Text& startRow, const std::vector<Text> & columns, const int64_t timestamp, const std::map<Text, Text> & attributes) {
6631     size_t sz = ifaces_.size();
6632     size_t i = 0;
6633     for (; i < (sz - 1); ++i) {
6634       ifaces_[i]->scannerOpenTs(tableName, startRow, columns, timestamp, attributes);
6635     }
6636     return ifaces_[i]->scannerOpenTs(tableName, startRow, columns, timestamp, attributes);
6637   }
6638 
scannerOpenWithStopTs(const Text & tableName,const Text & startRow,const Text & stopRow,const std::vector<Text> & columns,const int64_t timestamp,const std::map<Text,Text> & attributes)6639   ScannerID scannerOpenWithStopTs(const Text& tableName, const Text& startRow, const Text& stopRow, const std::vector<Text> & columns, const int64_t timestamp, const std::map<Text, Text> & attributes) {
6640     size_t sz = ifaces_.size();
6641     size_t i = 0;
6642     for (; i < (sz - 1); ++i) {
6643       ifaces_[i]->scannerOpenWithStopTs(tableName, startRow, stopRow, columns, timestamp, attributes);
6644     }
6645     return ifaces_[i]->scannerOpenWithStopTs(tableName, startRow, stopRow, columns, timestamp, attributes);
6646   }
6647 
scannerGet(std::vector<TRowResult> & _return,const ScannerID id)6648   void scannerGet(std::vector<TRowResult> & _return, const ScannerID id) {
6649     size_t sz = ifaces_.size();
6650     size_t i = 0;
6651     for (; i < (sz - 1); ++i) {
6652       ifaces_[i]->scannerGet(_return, id);
6653     }
6654     ifaces_[i]->scannerGet(_return, id);
6655     return;
6656   }
6657 
scannerGetList(std::vector<TRowResult> & _return,const ScannerID id,const int32_t nbRows)6658   void scannerGetList(std::vector<TRowResult> & _return, const ScannerID id, const int32_t nbRows) {
6659     size_t sz = ifaces_.size();
6660     size_t i = 0;
6661     for (; i < (sz - 1); ++i) {
6662       ifaces_[i]->scannerGetList(_return, id, nbRows);
6663     }
6664     ifaces_[i]->scannerGetList(_return, id, nbRows);
6665     return;
6666   }
6667 
scannerClose(const ScannerID id)6668   void scannerClose(const ScannerID id) {
6669     size_t sz = ifaces_.size();
6670     size_t i = 0;
6671     for (; i < (sz - 1); ++i) {
6672       ifaces_[i]->scannerClose(id);
6673     }
6674     ifaces_[i]->scannerClose(id);
6675   }
6676 
getRowOrBefore(std::vector<TCell> & _return,const Text & tableName,const Text & row,const Text & family)6677   void getRowOrBefore(std::vector<TCell> & _return, const Text& tableName, const Text& row, const Text& family) {
6678     size_t sz = ifaces_.size();
6679     size_t i = 0;
6680     for (; i < (sz - 1); ++i) {
6681       ifaces_[i]->getRowOrBefore(_return, tableName, row, family);
6682     }
6683     ifaces_[i]->getRowOrBefore(_return, tableName, row, family);
6684     return;
6685   }
6686 
getRegionInfo(TRegionInfo & _return,const Text & row)6687   void getRegionInfo(TRegionInfo& _return, const Text& row) {
6688     size_t sz = ifaces_.size();
6689     size_t i = 0;
6690     for (; i < (sz - 1); ++i) {
6691       ifaces_[i]->getRegionInfo(_return, row);
6692     }
6693     ifaces_[i]->getRegionInfo(_return, row);
6694     return;
6695   }
6696 
6697 };
6698 
6699 }}}} // namespace
6700 
6701 #endif
6702