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