/**
 * Autogenerated by Thrift
 *
 * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 */
#include "Hbase.h"

namespace apache { namespace hadoop { namespace hbase { namespace thrift {

uint32_t Hbase_enableTable_args::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRING) {
          xfer += iprot->readBinary(this->tableName);
          this->__isset.tableName = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_enableTable_args::write(facebook::thrift::protocol::TProtocol* oprot) const {
  uint32_t xfer = 0;
  xfer += oprot->writeStructBegin("Hbase_enableTable_args");
  xfer += oprot->writeFieldBegin("tableName", facebook::thrift::protocol::T_STRING, 1);
  xfer += oprot->writeBinary(this->tableName);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_enableTable_pargs::write(facebook::thrift::protocol::TProtocol* oprot) const {
  uint32_t xfer = 0;
  xfer += oprot->writeStructBegin("Hbase_enableTable_pargs");
  xfer += oprot->writeFieldBegin("tableName", facebook::thrift::protocol::T_STRING, 1);
  xfer += oprot->writeBinary((*(this->tableName)));
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_enableTable_result::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->io.read(iprot);
          this->__isset.io = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_enableTable_result::write(facebook::thrift::protocol::TProtocol* oprot) const {

  uint32_t xfer = 0;

  xfer += oprot->writeStructBegin("Hbase_enableTable_result");

  if (this->__isset.io) {
    xfer += oprot->writeFieldBegin("io", facebook::thrift::protocol::T_STRUCT, 1);
    xfer += this->io.write(oprot);
    xfer += oprot->writeFieldEnd();
  }
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_enableTable_presult::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->io.read(iprot);
          this->__isset.io = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_disableTable_args::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRING) {
          xfer += iprot->readBinary(this->tableName);
          this->__isset.tableName = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_disableTable_args::write(facebook::thrift::protocol::TProtocol* oprot) const {
  uint32_t xfer = 0;
  xfer += oprot->writeStructBegin("Hbase_disableTable_args");
  xfer += oprot->writeFieldBegin("tableName", facebook::thrift::protocol::T_STRING, 1);
  xfer += oprot->writeBinary(this->tableName);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_disableTable_pargs::write(facebook::thrift::protocol::TProtocol* oprot) const {
  uint32_t xfer = 0;
  xfer += oprot->writeStructBegin("Hbase_disableTable_pargs");
  xfer += oprot->writeFieldBegin("tableName", facebook::thrift::protocol::T_STRING, 1);
  xfer += oprot->writeBinary((*(this->tableName)));
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_disableTable_result::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->io.read(iprot);
          this->__isset.io = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_disableTable_result::write(facebook::thrift::protocol::TProtocol* oprot) const {

  uint32_t xfer = 0;

  xfer += oprot->writeStructBegin("Hbase_disableTable_result");

  if (this->__isset.io) {
    xfer += oprot->writeFieldBegin("io", facebook::thrift::protocol::T_STRUCT, 1);
    xfer += this->io.write(oprot);
    xfer += oprot->writeFieldEnd();
  }
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_disableTable_presult::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->io.read(iprot);
          this->__isset.io = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_isTableEnabled_args::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRING) {
          xfer += iprot->readBinary(this->tableName);
          this->__isset.tableName = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_isTableEnabled_args::write(facebook::thrift::protocol::TProtocol* oprot) const {
  uint32_t xfer = 0;
  xfer += oprot->writeStructBegin("Hbase_isTableEnabled_args");
  xfer += oprot->writeFieldBegin("tableName", facebook::thrift::protocol::T_STRING, 1);
  xfer += oprot->writeBinary(this->tableName);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_isTableEnabled_pargs::write(facebook::thrift::protocol::TProtocol* oprot) const {
  uint32_t xfer = 0;
  xfer += oprot->writeStructBegin("Hbase_isTableEnabled_pargs");
  xfer += oprot->writeFieldBegin("tableName", facebook::thrift::protocol::T_STRING, 1);
  xfer += oprot->writeBinary((*(this->tableName)));
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_isTableEnabled_result::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 0:
        if (ftype == facebook::thrift::protocol::T_BOOL) {
          xfer += iprot->readBool(this->success);
          this->__isset.success = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->io.read(iprot);
          this->__isset.io = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_isTableEnabled_result::write(facebook::thrift::protocol::TProtocol* oprot) const {

  uint32_t xfer = 0;

  xfer += oprot->writeStructBegin("Hbase_isTableEnabled_result");

  if (this->__isset.success) {
    xfer += oprot->writeFieldBegin("success", facebook::thrift::protocol::T_BOOL, 0);
    xfer += oprot->writeBool(this->success);
    xfer += oprot->writeFieldEnd();
  } else if (this->__isset.io) {
    xfer += oprot->writeFieldBegin("io", facebook::thrift::protocol::T_STRUCT, 1);
    xfer += this->io.write(oprot);
    xfer += oprot->writeFieldEnd();
  }
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_isTableEnabled_presult::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 0:
        if (ftype == facebook::thrift::protocol::T_BOOL) {
          xfer += iprot->readBool((*(this->success)));
          this->__isset.success = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->io.read(iprot);
          this->__isset.io = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_getTableNames_args::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_getTableNames_args::write(facebook::thrift::protocol::TProtocol* oprot) const {
  uint32_t xfer = 0;
  xfer += oprot->writeStructBegin("Hbase_getTableNames_args");
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_getTableNames_pargs::write(facebook::thrift::protocol::TProtocol* oprot) const {
  uint32_t xfer = 0;
  xfer += oprot->writeStructBegin("Hbase_getTableNames_pargs");
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_getTableNames_result::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 0:
        if (ftype == facebook::thrift::protocol::T_LIST) {
          {
            this->success.clear();
            uint32_t _size14;
            facebook::thrift::protocol::TType _etype17;
            iprot->readListBegin(_etype17, _size14);
            this->success.resize(_size14);
            uint32_t _i18;
            for (_i18 = 0; _i18 < _size14; ++_i18)
            {
              xfer += iprot->readBinary(this->success[_i18]);
            }
            iprot->readListEnd();
          }
          this->__isset.success = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->io.read(iprot);
          this->__isset.io = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_getTableNames_result::write(facebook::thrift::protocol::TProtocol* oprot) const {

  uint32_t xfer = 0;

  xfer += oprot->writeStructBegin("Hbase_getTableNames_result");

  if (this->__isset.success) {
    xfer += oprot->writeFieldBegin("success", facebook::thrift::protocol::T_LIST, 0);
    {
      xfer += oprot->writeListBegin(facebook::thrift::protocol::T_STRING, this->success.size());
      std::vector<Text> ::const_iterator _iter19;
      for (_iter19 = this->success.begin(); _iter19 != this->success.end(); ++_iter19)
      {
        xfer += oprot->writeBinary((*_iter19));
      }
      xfer += oprot->writeListEnd();
    }
    xfer += oprot->writeFieldEnd();
  } else if (this->__isset.io) {
    xfer += oprot->writeFieldBegin("io", facebook::thrift::protocol::T_STRUCT, 1);
    xfer += this->io.write(oprot);
    xfer += oprot->writeFieldEnd();
  }
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_getTableNames_presult::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 0:
        if (ftype == facebook::thrift::protocol::T_LIST) {
          {
            (*(this->success)).clear();
            uint32_t _size20;
            facebook::thrift::protocol::TType _etype23;
            iprot->readListBegin(_etype23, _size20);
            (*(this->success)).resize(_size20);
            uint32_t _i24;
            for (_i24 = 0; _i24 < _size20; ++_i24)
            {
              xfer += iprot->readBinary((*(this->success))[_i24]);
            }
            iprot->readListEnd();
          }
          this->__isset.success = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->io.read(iprot);
          this->__isset.io = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_getColumnDescriptors_args::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRING) {
          xfer += iprot->readBinary(this->tableName);
          this->__isset.tableName = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_getColumnDescriptors_args::write(facebook::thrift::protocol::TProtocol* oprot) const {
  uint32_t xfer = 0;
  xfer += oprot->writeStructBegin("Hbase_getColumnDescriptors_args");
  xfer += oprot->writeFieldBegin("tableName", facebook::thrift::protocol::T_STRING, 1);
  xfer += oprot->writeBinary(this->tableName);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_getColumnDescriptors_pargs::write(facebook::thrift::protocol::TProtocol* oprot) const {
  uint32_t xfer = 0;
  xfer += oprot->writeStructBegin("Hbase_getColumnDescriptors_pargs");
  xfer += oprot->writeFieldBegin("tableName", facebook::thrift::protocol::T_STRING, 1);
  xfer += oprot->writeBinary((*(this->tableName)));
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_getColumnDescriptors_result::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 0:
        if (ftype == facebook::thrift::protocol::T_MAP) {
          {
            this->success.clear();
            uint32_t _size25;
            facebook::thrift::protocol::TType _ktype26;
            facebook::thrift::protocol::TType _vtype27;
            iprot->readMapBegin(_ktype26, _vtype27, _size25);
            uint32_t _i29;
            for (_i29 = 0; _i29 < _size25; ++_i29)
            {
              Text _key30;
              xfer += iprot->readBinary(_key30);
              ColumnDescriptor& _val31 = this->success[_key30];
              xfer += _val31.read(iprot);
            }
            iprot->readMapEnd();
          }
          this->__isset.success = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->io.read(iprot);
          this->__isset.io = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_getColumnDescriptors_result::write(facebook::thrift::protocol::TProtocol* oprot) const {

  uint32_t xfer = 0;

  xfer += oprot->writeStructBegin("Hbase_getColumnDescriptors_result");

  if (this->__isset.success) {
    xfer += oprot->writeFieldBegin("success", facebook::thrift::protocol::T_MAP, 0);
    {
      xfer += oprot->writeMapBegin(facebook::thrift::protocol::T_STRING, facebook::thrift::protocol::T_STRUCT, this->success.size());
      std::map<Text, ColumnDescriptor> ::const_iterator _iter32;
      for (_iter32 = this->success.begin(); _iter32 != this->success.end(); ++_iter32)
      {
        xfer += oprot->writeBinary(_iter32->first);
        xfer += _iter32->second.write(oprot);
      }
      xfer += oprot->writeMapEnd();
    }
    xfer += oprot->writeFieldEnd();
  } else if (this->__isset.io) {
    xfer += oprot->writeFieldBegin("io", facebook::thrift::protocol::T_STRUCT, 1);
    xfer += this->io.write(oprot);
    xfer += oprot->writeFieldEnd();
  }
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_getColumnDescriptors_presult::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 0:
        if (ftype == facebook::thrift::protocol::T_MAP) {
          {
            (*(this->success)).clear();
            uint32_t _size33;
            facebook::thrift::protocol::TType _ktype34;
            facebook::thrift::protocol::TType _vtype35;
            iprot->readMapBegin(_ktype34, _vtype35, _size33);
            uint32_t _i37;
            for (_i37 = 0; _i37 < _size33; ++_i37)
            {
              Text _key38;
              xfer += iprot->readBinary(_key38);
              ColumnDescriptor& _val39 = (*(this->success))[_key38];
              xfer += _val39.read(iprot);
            }
            iprot->readMapEnd();
          }
          this->__isset.success = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->io.read(iprot);
          this->__isset.io = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_getTableRegions_args::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRING) {
          xfer += iprot->readBinary(this->tableName);
          this->__isset.tableName = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_getTableRegions_args::write(facebook::thrift::protocol::TProtocol* oprot) const {
  uint32_t xfer = 0;
  xfer += oprot->writeStructBegin("Hbase_getTableRegions_args");
  xfer += oprot->writeFieldBegin("tableName", facebook::thrift::protocol::T_STRING, 1);
  xfer += oprot->writeBinary(this->tableName);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_getTableRegions_pargs::write(facebook::thrift::protocol::TProtocol* oprot) const {
  uint32_t xfer = 0;
  xfer += oprot->writeStructBegin("Hbase_getTableRegions_pargs");
  xfer += oprot->writeFieldBegin("tableName", facebook::thrift::protocol::T_STRING, 1);
  xfer += oprot->writeBinary((*(this->tableName)));
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_getTableRegions_result::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 0:
        if (ftype == facebook::thrift::protocol::T_LIST) {
          {
            this->success.clear();
            uint32_t _size40;
            facebook::thrift::protocol::TType _etype43;
            iprot->readListBegin(_etype43, _size40);
            this->success.resize(_size40);
            uint32_t _i44;
            for (_i44 = 0; _i44 < _size40; ++_i44)
            {
              xfer += this->success[_i44].read(iprot);
            }
            iprot->readListEnd();
          }
          this->__isset.success = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->io.read(iprot);
          this->__isset.io = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_getTableRegions_result::write(facebook::thrift::protocol::TProtocol* oprot) const {

  uint32_t xfer = 0;

  xfer += oprot->writeStructBegin("Hbase_getTableRegions_result");

  if (this->__isset.success) {
    xfer += oprot->writeFieldBegin("success", facebook::thrift::protocol::T_LIST, 0);
    {
      xfer += oprot->writeListBegin(facebook::thrift::protocol::T_STRUCT, this->success.size());
      std::vector<TRegionInfo> ::const_iterator _iter45;
      for (_iter45 = this->success.begin(); _iter45 != this->success.end(); ++_iter45)
      {
        xfer += (*_iter45).write(oprot);
      }
      xfer += oprot->writeListEnd();
    }
    xfer += oprot->writeFieldEnd();
  } else if (this->__isset.io) {
    xfer += oprot->writeFieldBegin("io", facebook::thrift::protocol::T_STRUCT, 1);
    xfer += this->io.write(oprot);
    xfer += oprot->writeFieldEnd();
  }
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_getTableRegions_presult::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 0:
        if (ftype == facebook::thrift::protocol::T_LIST) {
          {
            (*(this->success)).clear();
            uint32_t _size46;
            facebook::thrift::protocol::TType _etype49;
            iprot->readListBegin(_etype49, _size46);
            (*(this->success)).resize(_size46);
            uint32_t _i50;
            for (_i50 = 0; _i50 < _size46; ++_i50)
            {
              xfer += (*(this->success))[_i50].read(iprot);
            }
            iprot->readListEnd();
          }
          this->__isset.success = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->io.read(iprot);
          this->__isset.io = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_createTable_args::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRING) {
          xfer += iprot->readBinary(this->tableName);
          this->__isset.tableName = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 2:
        if (ftype == facebook::thrift::protocol::T_LIST) {
          {
            this->columnFamilies.clear();
            uint32_t _size51;
            facebook::thrift::protocol::TType _etype54;
            iprot->readListBegin(_etype54, _size51);
            this->columnFamilies.resize(_size51);
            uint32_t _i55;
            for (_i55 = 0; _i55 < _size51; ++_i55)
            {
              xfer += this->columnFamilies[_i55].read(iprot);
            }
            iprot->readListEnd();
          }
          this->__isset.columnFamilies = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_createTable_args::write(facebook::thrift::protocol::TProtocol* oprot) const {
  uint32_t xfer = 0;
  xfer += oprot->writeStructBegin("Hbase_createTable_args");
  xfer += oprot->writeFieldBegin("tableName", facebook::thrift::protocol::T_STRING, 1);
  xfer += oprot->writeBinary(this->tableName);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("columnFamilies", facebook::thrift::protocol::T_LIST, 2);
  {
    xfer += oprot->writeListBegin(facebook::thrift::protocol::T_STRUCT, this->columnFamilies.size());
    std::vector<ColumnDescriptor> ::const_iterator _iter56;
    for (_iter56 = this->columnFamilies.begin(); _iter56 != this->columnFamilies.end(); ++_iter56)
    {
      xfer += (*_iter56).write(oprot);
    }
    xfer += oprot->writeListEnd();
  }
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_createTable_pargs::write(facebook::thrift::protocol::TProtocol* oprot) const {
  uint32_t xfer = 0;
  xfer += oprot->writeStructBegin("Hbase_createTable_pargs");
  xfer += oprot->writeFieldBegin("tableName", facebook::thrift::protocol::T_STRING, 1);
  xfer += oprot->writeBinary((*(this->tableName)));
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("columnFamilies", facebook::thrift::protocol::T_LIST, 2);
  {
    xfer += oprot->writeListBegin(facebook::thrift::protocol::T_STRUCT, (*(this->columnFamilies)).size());
    std::vector<ColumnDescriptor> ::const_iterator _iter57;
    for (_iter57 = (*(this->columnFamilies)).begin(); _iter57 != (*(this->columnFamilies)).end(); ++_iter57)
    {
      xfer += (*_iter57).write(oprot);
    }
    xfer += oprot->writeListEnd();
  }
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_createTable_result::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->io.read(iprot);
          this->__isset.io = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 2:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->ia.read(iprot);
          this->__isset.ia = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 3:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->exist.read(iprot);
          this->__isset.exist = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_createTable_result::write(facebook::thrift::protocol::TProtocol* oprot) const {

  uint32_t xfer = 0;

  xfer += oprot->writeStructBegin("Hbase_createTable_result");

  if (this->__isset.io) {
    xfer += oprot->writeFieldBegin("io", facebook::thrift::protocol::T_STRUCT, 1);
    xfer += this->io.write(oprot);
    xfer += oprot->writeFieldEnd();
  } else if (this->__isset.ia) {
    xfer += oprot->writeFieldBegin("ia", facebook::thrift::protocol::T_STRUCT, 2);
    xfer += this->ia.write(oprot);
    xfer += oprot->writeFieldEnd();
  } else if (this->__isset.exist) {
    xfer += oprot->writeFieldBegin("exist", facebook::thrift::protocol::T_STRUCT, 3);
    xfer += this->exist.write(oprot);
    xfer += oprot->writeFieldEnd();
  }
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_createTable_presult::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->io.read(iprot);
          this->__isset.io = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 2:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->ia.read(iprot);
          this->__isset.ia = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 3:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->exist.read(iprot);
          this->__isset.exist = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_deleteTable_args::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRING) {
          xfer += iprot->readBinary(this->tableName);
          this->__isset.tableName = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_deleteTable_args::write(facebook::thrift::protocol::TProtocol* oprot) const {
  uint32_t xfer = 0;
  xfer += oprot->writeStructBegin("Hbase_deleteTable_args");
  xfer += oprot->writeFieldBegin("tableName", facebook::thrift::protocol::T_STRING, 1);
  xfer += oprot->writeBinary(this->tableName);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_deleteTable_pargs::write(facebook::thrift::protocol::TProtocol* oprot) const {
  uint32_t xfer = 0;
  xfer += oprot->writeStructBegin("Hbase_deleteTable_pargs");
  xfer += oprot->writeFieldBegin("tableName", facebook::thrift::protocol::T_STRING, 1);
  xfer += oprot->writeBinary((*(this->tableName)));
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_deleteTable_result::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->io.read(iprot);
          this->__isset.io = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 2:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->nf.read(iprot);
          this->__isset.nf = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_deleteTable_result::write(facebook::thrift::protocol::TProtocol* oprot) const {

  uint32_t xfer = 0;

  xfer += oprot->writeStructBegin("Hbase_deleteTable_result");

  if (this->__isset.io) {
    xfer += oprot->writeFieldBegin("io", facebook::thrift::protocol::T_STRUCT, 1);
    xfer += this->io.write(oprot);
    xfer += oprot->writeFieldEnd();
  } else if (this->__isset.nf) {
    xfer += oprot->writeFieldBegin("nf", facebook::thrift::protocol::T_STRUCT, 2);
    xfer += this->nf.write(oprot);
    xfer += oprot->writeFieldEnd();
  }
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_deleteTable_presult::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->io.read(iprot);
          this->__isset.io = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 2:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->nf.read(iprot);
          this->__isset.nf = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_get_args::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRING) {
          xfer += iprot->readBinary(this->tableName);
          this->__isset.tableName = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 2:
        if (ftype == facebook::thrift::protocol::T_STRING) {
          xfer += iprot->readBinary(this->row);
          this->__isset.row = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 3:
        if (ftype == facebook::thrift::protocol::T_STRING) {
          xfer += iprot->readBinary(this->column);
          this->__isset.column = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_get_args::write(facebook::thrift::protocol::TProtocol* oprot) const {
  uint32_t xfer = 0;
  xfer += oprot->writeStructBegin("Hbase_get_args");
  xfer += oprot->writeFieldBegin("tableName", facebook::thrift::protocol::T_STRING, 1);
  xfer += oprot->writeBinary(this->tableName);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("row", facebook::thrift::protocol::T_STRING, 2);
  xfer += oprot->writeBinary(this->row);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("column", facebook::thrift::protocol::T_STRING, 3);
  xfer += oprot->writeBinary(this->column);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_get_pargs::write(facebook::thrift::protocol::TProtocol* oprot) const {
  uint32_t xfer = 0;
  xfer += oprot->writeStructBegin("Hbase_get_pargs");
  xfer += oprot->writeFieldBegin("tableName", facebook::thrift::protocol::T_STRING, 1);
  xfer += oprot->writeBinary((*(this->tableName)));
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("row", facebook::thrift::protocol::T_STRING, 2);
  xfer += oprot->writeBinary((*(this->row)));
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("column", facebook::thrift::protocol::T_STRING, 3);
  xfer += oprot->writeBinary((*(this->column)));
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_get_result::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 0:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->success.read(iprot);
          this->__isset.success = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->io.read(iprot);
          this->__isset.io = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 2:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->nf.read(iprot);
          this->__isset.nf = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_get_result::write(facebook::thrift::protocol::TProtocol* oprot) const {

  uint32_t xfer = 0;

  xfer += oprot->writeStructBegin("Hbase_get_result");

  if (this->__isset.success) {
    xfer += oprot->writeFieldBegin("success", facebook::thrift::protocol::T_STRUCT, 0);
    xfer += this->success.write(oprot);
    xfer += oprot->writeFieldEnd();
  } else if (this->__isset.io) {
    xfer += oprot->writeFieldBegin("io", facebook::thrift::protocol::T_STRUCT, 1);
    xfer += this->io.write(oprot);
    xfer += oprot->writeFieldEnd();
  } else if (this->__isset.nf) {
    xfer += oprot->writeFieldBegin("nf", facebook::thrift::protocol::T_STRUCT, 2);
    xfer += this->nf.write(oprot);
    xfer += oprot->writeFieldEnd();
  }
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_get_presult::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 0:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += (*(this->success)).read(iprot);
          this->__isset.success = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->io.read(iprot);
          this->__isset.io = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 2:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->nf.read(iprot);
          this->__isset.nf = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_getVer_args::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRING) {
          xfer += iprot->readBinary(this->tableName);
          this->__isset.tableName = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 2:
        if (ftype == facebook::thrift::protocol::T_STRING) {
          xfer += iprot->readBinary(this->row);
          this->__isset.row = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 3:
        if (ftype == facebook::thrift::protocol::T_STRING) {
          xfer += iprot->readBinary(this->column);
          this->__isset.column = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 4:
        if (ftype == facebook::thrift::protocol::T_I32) {
          xfer += iprot->readI32(this->numVersions);
          this->__isset.numVersions = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_getVer_args::write(facebook::thrift::protocol::TProtocol* oprot) const {
  uint32_t xfer = 0;
  xfer += oprot->writeStructBegin("Hbase_getVer_args");
  xfer += oprot->writeFieldBegin("tableName", facebook::thrift::protocol::T_STRING, 1);
  xfer += oprot->writeBinary(this->tableName);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("row", facebook::thrift::protocol::T_STRING, 2);
  xfer += oprot->writeBinary(this->row);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("column", facebook::thrift::protocol::T_STRING, 3);
  xfer += oprot->writeBinary(this->column);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("numVersions", facebook::thrift::protocol::T_I32, 4);
  xfer += oprot->writeI32(this->numVersions);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_getVer_pargs::write(facebook::thrift::protocol::TProtocol* oprot) const {
  uint32_t xfer = 0;
  xfer += oprot->writeStructBegin("Hbase_getVer_pargs");
  xfer += oprot->writeFieldBegin("tableName", facebook::thrift::protocol::T_STRING, 1);
  xfer += oprot->writeBinary((*(this->tableName)));
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("row", facebook::thrift::protocol::T_STRING, 2);
  xfer += oprot->writeBinary((*(this->row)));
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("column", facebook::thrift::protocol::T_STRING, 3);
  xfer += oprot->writeBinary((*(this->column)));
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("numVersions", facebook::thrift::protocol::T_I32, 4);
  xfer += oprot->writeI32((*(this->numVersions)));
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_getVer_result::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 0:
        if (ftype == facebook::thrift::protocol::T_LIST) {
          {
            this->success.clear();
            uint32_t _size58;
            facebook::thrift::protocol::TType _etype61;
            iprot->readListBegin(_etype61, _size58);
            this->success.resize(_size58);
            uint32_t _i62;
            for (_i62 = 0; _i62 < _size58; ++_i62)
            {
              xfer += this->success[_i62].read(iprot);
            }
            iprot->readListEnd();
          }
          this->__isset.success = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->io.read(iprot);
          this->__isset.io = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 2:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->nf.read(iprot);
          this->__isset.nf = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_getVer_result::write(facebook::thrift::protocol::TProtocol* oprot) const {

  uint32_t xfer = 0;

  xfer += oprot->writeStructBegin("Hbase_getVer_result");

  if (this->__isset.success) {
    xfer += oprot->writeFieldBegin("success", facebook::thrift::protocol::T_LIST, 0);
    {
      xfer += oprot->writeListBegin(facebook::thrift::protocol::T_STRUCT, this->success.size());
      std::vector<TCell> ::const_iterator _iter63;
      for (_iter63 = this->success.begin(); _iter63 != this->success.end(); ++_iter63)
      {
        xfer += (*_iter63).write(oprot);
      }
      xfer += oprot->writeListEnd();
    }
    xfer += oprot->writeFieldEnd();
  } else if (this->__isset.io) {
    xfer += oprot->writeFieldBegin("io", facebook::thrift::protocol::T_STRUCT, 1);
    xfer += this->io.write(oprot);
    xfer += oprot->writeFieldEnd();
  } else if (this->__isset.nf) {
    xfer += oprot->writeFieldBegin("nf", facebook::thrift::protocol::T_STRUCT, 2);
    xfer += this->nf.write(oprot);
    xfer += oprot->writeFieldEnd();
  }
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_getVer_presult::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 0:
        if (ftype == facebook::thrift::protocol::T_LIST) {
          {
            (*(this->success)).clear();
            uint32_t _size64;
            facebook::thrift::protocol::TType _etype67;
            iprot->readListBegin(_etype67, _size64);
            (*(this->success)).resize(_size64);
            uint32_t _i68;
            for (_i68 = 0; _i68 < _size64; ++_i68)
            {
              xfer += (*(this->success))[_i68].read(iprot);
            }
            iprot->readListEnd();
          }
          this->__isset.success = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->io.read(iprot);
          this->__isset.io = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 2:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->nf.read(iprot);
          this->__isset.nf = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_getVerTs_args::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRING) {
          xfer += iprot->readBinary(this->tableName);
          this->__isset.tableName = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 2:
        if (ftype == facebook::thrift::protocol::T_STRING) {
          xfer += iprot->readBinary(this->row);
          this->__isset.row = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 3:
        if (ftype == facebook::thrift::protocol::T_STRING) {
          xfer += iprot->readBinary(this->column);
          this->__isset.column = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 4:
        if (ftype == facebook::thrift::protocol::T_I64) {
          xfer += iprot->readI64(this->timestamp);
          this->__isset.timestamp = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 5:
        if (ftype == facebook::thrift::protocol::T_I32) {
          xfer += iprot->readI32(this->numVersions);
          this->__isset.numVersions = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_getVerTs_args::write(facebook::thrift::protocol::TProtocol* oprot) const {
  uint32_t xfer = 0;
  xfer += oprot->writeStructBegin("Hbase_getVerTs_args");
  xfer += oprot->writeFieldBegin("tableName", facebook::thrift::protocol::T_STRING, 1);
  xfer += oprot->writeBinary(this->tableName);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("row", facebook::thrift::protocol::T_STRING, 2);
  xfer += oprot->writeBinary(this->row);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("column", facebook::thrift::protocol::T_STRING, 3);
  xfer += oprot->writeBinary(this->column);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("timestamp", facebook::thrift::protocol::T_I64, 4);
  xfer += oprot->writeI64(this->timestamp);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("numVersions", facebook::thrift::protocol::T_I32, 5);
  xfer += oprot->writeI32(this->numVersions);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_getVerTs_pargs::write(facebook::thrift::protocol::TProtocol* oprot) const {
  uint32_t xfer = 0;
  xfer += oprot->writeStructBegin("Hbase_getVerTs_pargs");
  xfer += oprot->writeFieldBegin("tableName", facebook::thrift::protocol::T_STRING, 1);
  xfer += oprot->writeBinary((*(this->tableName)));
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("row", facebook::thrift::protocol::T_STRING, 2);
  xfer += oprot->writeBinary((*(this->row)));
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("column", facebook::thrift::protocol::T_STRING, 3);
  xfer += oprot->writeBinary((*(this->column)));
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("timestamp", facebook::thrift::protocol::T_I64, 4);
  xfer += oprot->writeI64((*(this->timestamp)));
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("numVersions", facebook::thrift::protocol::T_I32, 5);
  xfer += oprot->writeI32((*(this->numVersions)));
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_getVerTs_result::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 0:
        if (ftype == facebook::thrift::protocol::T_LIST) {
          {
            this->success.clear();
            uint32_t _size69;
            facebook::thrift::protocol::TType _etype72;
            iprot->readListBegin(_etype72, _size69);
            this->success.resize(_size69);
            uint32_t _i73;
            for (_i73 = 0; _i73 < _size69; ++_i73)
            {
              xfer += this->success[_i73].read(iprot);
            }
            iprot->readListEnd();
          }
          this->__isset.success = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->io.read(iprot);
          this->__isset.io = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 2:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->nf.read(iprot);
          this->__isset.nf = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_getVerTs_result::write(facebook::thrift::protocol::TProtocol* oprot) const {

  uint32_t xfer = 0;

  xfer += oprot->writeStructBegin("Hbase_getVerTs_result");

  if (this->__isset.success) {
    xfer += oprot->writeFieldBegin("success", facebook::thrift::protocol::T_LIST, 0);
    {
      xfer += oprot->writeListBegin(facebook::thrift::protocol::T_STRUCT, this->success.size());
      std::vector<TCell> ::const_iterator _iter74;
      for (_iter74 = this->success.begin(); _iter74 != this->success.end(); ++_iter74)
      {
        xfer += (*_iter74).write(oprot);
      }
      xfer += oprot->writeListEnd();
    }
    xfer += oprot->writeFieldEnd();
  } else if (this->__isset.io) {
    xfer += oprot->writeFieldBegin("io", facebook::thrift::protocol::T_STRUCT, 1);
    xfer += this->io.write(oprot);
    xfer += oprot->writeFieldEnd();
  } else if (this->__isset.nf) {
    xfer += oprot->writeFieldBegin("nf", facebook::thrift::protocol::T_STRUCT, 2);
    xfer += this->nf.write(oprot);
    xfer += oprot->writeFieldEnd();
  }
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_getVerTs_presult::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 0:
        if (ftype == facebook::thrift::protocol::T_LIST) {
          {
            (*(this->success)).clear();
            uint32_t _size75;
            facebook::thrift::protocol::TType _etype78;
            iprot->readListBegin(_etype78, _size75);
            (*(this->success)).resize(_size75);
            uint32_t _i79;
            for (_i79 = 0; _i79 < _size75; ++_i79)
            {
              xfer += (*(this->success))[_i79].read(iprot);
            }
            iprot->readListEnd();
          }
          this->__isset.success = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->io.read(iprot);
          this->__isset.io = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 2:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->nf.read(iprot);
          this->__isset.nf = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_getRow_args::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRING) {
          xfer += iprot->readBinary(this->tableName);
          this->__isset.tableName = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 2:
        if (ftype == facebook::thrift::protocol::T_STRING) {
          xfer += iprot->readBinary(this->row);
          this->__isset.row = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_getRow_args::write(facebook::thrift::protocol::TProtocol* oprot) const {
  uint32_t xfer = 0;
  xfer += oprot->writeStructBegin("Hbase_getRow_args");
  xfer += oprot->writeFieldBegin("tableName", facebook::thrift::protocol::T_STRING, 1);
  xfer += oprot->writeBinary(this->tableName);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("row", facebook::thrift::protocol::T_STRING, 2);
  xfer += oprot->writeBinary(this->row);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_getRow_pargs::write(facebook::thrift::protocol::TProtocol* oprot) const {
  uint32_t xfer = 0;
  xfer += oprot->writeStructBegin("Hbase_getRow_pargs");
  xfer += oprot->writeFieldBegin("tableName", facebook::thrift::protocol::T_STRING, 1);
  xfer += oprot->writeBinary((*(this->tableName)));
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("row", facebook::thrift::protocol::T_STRING, 2);
  xfer += oprot->writeBinary((*(this->row)));
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_getRow_result::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 0:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->success.read(iprot);
          this->__isset.success = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->io.read(iprot);
          this->__isset.io = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_getRow_result::write(facebook::thrift::protocol::TProtocol* oprot) const {

  uint32_t xfer = 0;

  xfer += oprot->writeStructBegin("Hbase_getRow_result");

  if (this->__isset.success) {
    xfer += oprot->writeFieldBegin("success", facebook::thrift::protocol::T_STRUCT, 0);
    xfer += this->success.write(oprot);
    xfer += oprot->writeFieldEnd();
  } else if (this->__isset.io) {
    xfer += oprot->writeFieldBegin("io", facebook::thrift::protocol::T_STRUCT, 1);
    xfer += this->io.write(oprot);
    xfer += oprot->writeFieldEnd();
  }
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_getRow_presult::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 0:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += (*(this->success)).read(iprot);
          this->__isset.success = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->io.read(iprot);
          this->__isset.io = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_getRowTs_args::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRING) {
          xfer += iprot->readBinary(this->tableName);
          this->__isset.tableName = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 2:
        if (ftype == facebook::thrift::protocol::T_STRING) {
          xfer += iprot->readBinary(this->row);
          this->__isset.row = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 3:
        if (ftype == facebook::thrift::protocol::T_I64) {
          xfer += iprot->readI64(this->timestamp);
          this->__isset.timestamp = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_getRowTs_args::write(facebook::thrift::protocol::TProtocol* oprot) const {
  uint32_t xfer = 0;
  xfer += oprot->writeStructBegin("Hbase_getRowTs_args");
  xfer += oprot->writeFieldBegin("tableName", facebook::thrift::protocol::T_STRING, 1);
  xfer += oprot->writeBinary(this->tableName);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("row", facebook::thrift::protocol::T_STRING, 2);
  xfer += oprot->writeBinary(this->row);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("timestamp", facebook::thrift::protocol::T_I64, 3);
  xfer += oprot->writeI64(this->timestamp);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_getRowTs_pargs::write(facebook::thrift::protocol::TProtocol* oprot) const {
  uint32_t xfer = 0;
  xfer += oprot->writeStructBegin("Hbase_getRowTs_pargs");
  xfer += oprot->writeFieldBegin("tableName", facebook::thrift::protocol::T_STRING, 1);
  xfer += oprot->writeBinary((*(this->tableName)));
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("row", facebook::thrift::protocol::T_STRING, 2);
  xfer += oprot->writeBinary((*(this->row)));
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("timestamp", facebook::thrift::protocol::T_I64, 3);
  xfer += oprot->writeI64((*(this->timestamp)));
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_getRowTs_result::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 0:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->success.read(iprot);
          this->__isset.success = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->io.read(iprot);
          this->__isset.io = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_getRowTs_result::write(facebook::thrift::protocol::TProtocol* oprot) const {

  uint32_t xfer = 0;

  xfer += oprot->writeStructBegin("Hbase_getRowTs_result");

  if (this->__isset.success) {
    xfer += oprot->writeFieldBegin("success", facebook::thrift::protocol::T_STRUCT, 0);
    xfer += this->success.write(oprot);
    xfer += oprot->writeFieldEnd();
  } else if (this->__isset.io) {
    xfer += oprot->writeFieldBegin("io", facebook::thrift::protocol::T_STRUCT, 1);
    xfer += this->io.write(oprot);
    xfer += oprot->writeFieldEnd();
  }
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_getRowTs_presult::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 0:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += (*(this->success)).read(iprot);
          this->__isset.success = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->io.read(iprot);
          this->__isset.io = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_mutateRow_args::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRING) {
          xfer += iprot->readBinary(this->tableName);
          this->__isset.tableName = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 2:
        if (ftype == facebook::thrift::protocol::T_STRING) {
          xfer += iprot->readBinary(this->row);
          this->__isset.row = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 3:
        if (ftype == facebook::thrift::protocol::T_LIST) {
          {
            this->mutations.clear();
            uint32_t _size80;
            facebook::thrift::protocol::TType _etype83;
            iprot->readListBegin(_etype83, _size80);
            this->mutations.resize(_size80);
            uint32_t _i84;
            for (_i84 = 0; _i84 < _size80; ++_i84)
            {
              xfer += this->mutations[_i84].read(iprot);
            }
            iprot->readListEnd();
          }
          this->__isset.mutations = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_mutateRow_args::write(facebook::thrift::protocol::TProtocol* oprot) const {
  uint32_t xfer = 0;
  xfer += oprot->writeStructBegin("Hbase_mutateRow_args");
  xfer += oprot->writeFieldBegin("tableName", facebook::thrift::protocol::T_STRING, 1);
  xfer += oprot->writeBinary(this->tableName);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("row", facebook::thrift::protocol::T_STRING, 2);
  xfer += oprot->writeBinary(this->row);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("mutations", facebook::thrift::protocol::T_LIST, 3);
  {
    xfer += oprot->writeListBegin(facebook::thrift::protocol::T_STRUCT, this->mutations.size());
    std::vector<Mutation> ::const_iterator _iter85;
    for (_iter85 = this->mutations.begin(); _iter85 != this->mutations.end(); ++_iter85)
    {
      xfer += (*_iter85).write(oprot);
    }
    xfer += oprot->writeListEnd();
  }
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_mutateRow_pargs::write(facebook::thrift::protocol::TProtocol* oprot) const {
  uint32_t xfer = 0;
  xfer += oprot->writeStructBegin("Hbase_mutateRow_pargs");
  xfer += oprot->writeFieldBegin("tableName", facebook::thrift::protocol::T_STRING, 1);
  xfer += oprot->writeBinary((*(this->tableName)));
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("row", facebook::thrift::protocol::T_STRING, 2);
  xfer += oprot->writeBinary((*(this->row)));
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("mutations", facebook::thrift::protocol::T_LIST, 3);
  {
    xfer += oprot->writeListBegin(facebook::thrift::protocol::T_STRUCT, (*(this->mutations)).size());
    std::vector<Mutation> ::const_iterator _iter86;
    for (_iter86 = (*(this->mutations)).begin(); _iter86 != (*(this->mutations)).end(); ++_iter86)
    {
      xfer += (*_iter86).write(oprot);
    }
    xfer += oprot->writeListEnd();
  }
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_mutateRow_result::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->io.read(iprot);
          this->__isset.io = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 2:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->ia.read(iprot);
          this->__isset.ia = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_mutateRow_result::write(facebook::thrift::protocol::TProtocol* oprot) const {

  uint32_t xfer = 0;

  xfer += oprot->writeStructBegin("Hbase_mutateRow_result");

  if (this->__isset.io) {
    xfer += oprot->writeFieldBegin("io", facebook::thrift::protocol::T_STRUCT, 1);
    xfer += this->io.write(oprot);
    xfer += oprot->writeFieldEnd();
  } else if (this->__isset.ia) {
    xfer += oprot->writeFieldBegin("ia", facebook::thrift::protocol::T_STRUCT, 2);
    xfer += this->ia.write(oprot);
    xfer += oprot->writeFieldEnd();
  }
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_mutateRow_presult::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->io.read(iprot);
          this->__isset.io = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 2:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->ia.read(iprot);
          this->__isset.ia = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_mutateRowTs_args::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRING) {
          xfer += iprot->readBinary(this->tableName);
          this->__isset.tableName = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 2:
        if (ftype == facebook::thrift::protocol::T_STRING) {
          xfer += iprot->readBinary(this->row);
          this->__isset.row = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 3:
        if (ftype == facebook::thrift::protocol::T_LIST) {
          {
            this->mutations.clear();
            uint32_t _size87;
            facebook::thrift::protocol::TType _etype90;
            iprot->readListBegin(_etype90, _size87);
            this->mutations.resize(_size87);
            uint32_t _i91;
            for (_i91 = 0; _i91 < _size87; ++_i91)
            {
              xfer += this->mutations[_i91].read(iprot);
            }
            iprot->readListEnd();
          }
          this->__isset.mutations = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 4:
        if (ftype == facebook::thrift::protocol::T_I64) {
          xfer += iprot->readI64(this->timestamp);
          this->__isset.timestamp = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_mutateRowTs_args::write(facebook::thrift::protocol::TProtocol* oprot) const {
  uint32_t xfer = 0;
  xfer += oprot->writeStructBegin("Hbase_mutateRowTs_args");
  xfer += oprot->writeFieldBegin("tableName", facebook::thrift::protocol::T_STRING, 1);
  xfer += oprot->writeBinary(this->tableName);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("row", facebook::thrift::protocol::T_STRING, 2);
  xfer += oprot->writeBinary(this->row);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("mutations", facebook::thrift::protocol::T_LIST, 3);
  {
    xfer += oprot->writeListBegin(facebook::thrift::protocol::T_STRUCT, this->mutations.size());
    std::vector<Mutation> ::const_iterator _iter92;
    for (_iter92 = this->mutations.begin(); _iter92 != this->mutations.end(); ++_iter92)
    {
      xfer += (*_iter92).write(oprot);
    }
    xfer += oprot->writeListEnd();
  }
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("timestamp", facebook::thrift::protocol::T_I64, 4);
  xfer += oprot->writeI64(this->timestamp);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_mutateRowTs_pargs::write(facebook::thrift::protocol::TProtocol* oprot) const {
  uint32_t xfer = 0;
  xfer += oprot->writeStructBegin("Hbase_mutateRowTs_pargs");
  xfer += oprot->writeFieldBegin("tableName", facebook::thrift::protocol::T_STRING, 1);
  xfer += oprot->writeBinary((*(this->tableName)));
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("row", facebook::thrift::protocol::T_STRING, 2);
  xfer += oprot->writeBinary((*(this->row)));
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("mutations", facebook::thrift::protocol::T_LIST, 3);
  {
    xfer += oprot->writeListBegin(facebook::thrift::protocol::T_STRUCT, (*(this->mutations)).size());
    std::vector<Mutation> ::const_iterator _iter93;
    for (_iter93 = (*(this->mutations)).begin(); _iter93 != (*(this->mutations)).end(); ++_iter93)
    {
      xfer += (*_iter93).write(oprot);
    }
    xfer += oprot->writeListEnd();
  }
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("timestamp", facebook::thrift::protocol::T_I64, 4);
  xfer += oprot->writeI64((*(this->timestamp)));
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_mutateRowTs_result::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->io.read(iprot);
          this->__isset.io = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 2:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->ia.read(iprot);
          this->__isset.ia = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_mutateRowTs_result::write(facebook::thrift::protocol::TProtocol* oprot) const {

  uint32_t xfer = 0;

  xfer += oprot->writeStructBegin("Hbase_mutateRowTs_result");

  if (this->__isset.io) {
    xfer += oprot->writeFieldBegin("io", facebook::thrift::protocol::T_STRUCT, 1);
    xfer += this->io.write(oprot);
    xfer += oprot->writeFieldEnd();
  } else if (this->__isset.ia) {
    xfer += oprot->writeFieldBegin("ia", facebook::thrift::protocol::T_STRUCT, 2);
    xfer += this->ia.write(oprot);
    xfer += oprot->writeFieldEnd();
  }
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_mutateRowTs_presult::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->io.read(iprot);
          this->__isset.io = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 2:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->ia.read(iprot);
          this->__isset.ia = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_mutateRows_args::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRING) {
          xfer += iprot->readBinary(this->tableName);
          this->__isset.tableName = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 2:
        if (ftype == facebook::thrift::protocol::T_LIST) {
          {
            this->rowBatches.clear();
            uint32_t _size94;
            facebook::thrift::protocol::TType _etype97;
            iprot->readListBegin(_etype97, _size94);
            this->rowBatches.resize(_size94);
            uint32_t _i98;
            for (_i98 = 0; _i98 < _size94; ++_i98)
            {
              xfer += this->rowBatches[_i98].read(iprot);
            }
            iprot->readListEnd();
          }
          this->__isset.rowBatches = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_mutateRows_args::write(facebook::thrift::protocol::TProtocol* oprot) const {
  uint32_t xfer = 0;
  xfer += oprot->writeStructBegin("Hbase_mutateRows_args");
  xfer += oprot->writeFieldBegin("tableName", facebook::thrift::protocol::T_STRING, 1);
  xfer += oprot->writeBinary(this->tableName);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("rowBatches", facebook::thrift::protocol::T_LIST, 2);
  {
    xfer += oprot->writeListBegin(facebook::thrift::protocol::T_STRUCT, this->rowBatches.size());
    std::vector<BatchMutation> ::const_iterator _iter99;
    for (_iter99 = this->rowBatches.begin(); _iter99 != this->rowBatches.end(); ++_iter99)
    {
      xfer += (*_iter99).write(oprot);
    }
    xfer += oprot->writeListEnd();
  }
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_mutateRows_pargs::write(facebook::thrift::protocol::TProtocol* oprot) const {
  uint32_t xfer = 0;
  xfer += oprot->writeStructBegin("Hbase_mutateRows_pargs");
  xfer += oprot->writeFieldBegin("tableName", facebook::thrift::protocol::T_STRING, 1);
  xfer += oprot->writeBinary((*(this->tableName)));
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("rowBatches", facebook::thrift::protocol::T_LIST, 2);
  {
    xfer += oprot->writeListBegin(facebook::thrift::protocol::T_STRUCT, (*(this->rowBatches)).size());
    std::vector<BatchMutation> ::const_iterator _iter100;
    for (_iter100 = (*(this->rowBatches)).begin(); _iter100 != (*(this->rowBatches)).end(); ++_iter100)
    {
      xfer += (*_iter100).write(oprot);
    }
    xfer += oprot->writeListEnd();
  }
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_mutateRows_result::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->io.read(iprot);
          this->__isset.io = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 2:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->ia.read(iprot);
          this->__isset.ia = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_mutateRows_result::write(facebook::thrift::protocol::TProtocol* oprot) const {

  uint32_t xfer = 0;

  xfer += oprot->writeStructBegin("Hbase_mutateRows_result");

  if (this->__isset.io) {
    xfer += oprot->writeFieldBegin("io", facebook::thrift::protocol::T_STRUCT, 1);
    xfer += this->io.write(oprot);
    xfer += oprot->writeFieldEnd();
  } else if (this->__isset.ia) {
    xfer += oprot->writeFieldBegin("ia", facebook::thrift::protocol::T_STRUCT, 2);
    xfer += this->ia.write(oprot);
    xfer += oprot->writeFieldEnd();
  }
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_mutateRows_presult::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->io.read(iprot);
          this->__isset.io = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 2:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->ia.read(iprot);
          this->__isset.ia = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_mutateRowsTs_args::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRING) {
          xfer += iprot->readBinary(this->tableName);
          this->__isset.tableName = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 2:
        if (ftype == facebook::thrift::protocol::T_LIST) {
          {
            this->rowBatches.clear();
            uint32_t _size101;
            facebook::thrift::protocol::TType _etype104;
            iprot->readListBegin(_etype104, _size101);
            this->rowBatches.resize(_size101);
            uint32_t _i105;
            for (_i105 = 0; _i105 < _size101; ++_i105)
            {
              xfer += this->rowBatches[_i105].read(iprot);
            }
            iprot->readListEnd();
          }
          this->__isset.rowBatches = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 3:
        if (ftype == facebook::thrift::protocol::T_I64) {
          xfer += iprot->readI64(this->timestamp);
          this->__isset.timestamp = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_mutateRowsTs_args::write(facebook::thrift::protocol::TProtocol* oprot) const {
  uint32_t xfer = 0;
  xfer += oprot->writeStructBegin("Hbase_mutateRowsTs_args");
  xfer += oprot->writeFieldBegin("tableName", facebook::thrift::protocol::T_STRING, 1);
  xfer += oprot->writeBinary(this->tableName);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("rowBatches", facebook::thrift::protocol::T_LIST, 2);
  {
    xfer += oprot->writeListBegin(facebook::thrift::protocol::T_STRUCT, this->rowBatches.size());
    std::vector<BatchMutation> ::const_iterator _iter106;
    for (_iter106 = this->rowBatches.begin(); _iter106 != this->rowBatches.end(); ++_iter106)
    {
      xfer += (*_iter106).write(oprot);
    }
    xfer += oprot->writeListEnd();
  }
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("timestamp", facebook::thrift::protocol::T_I64, 3);
  xfer += oprot->writeI64(this->timestamp);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_mutateRowsTs_pargs::write(facebook::thrift::protocol::TProtocol* oprot) const {
  uint32_t xfer = 0;
  xfer += oprot->writeStructBegin("Hbase_mutateRowsTs_pargs");
  xfer += oprot->writeFieldBegin("tableName", facebook::thrift::protocol::T_STRING, 1);
  xfer += oprot->writeBinary((*(this->tableName)));
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("rowBatches", facebook::thrift::protocol::T_LIST, 2);
  {
    xfer += oprot->writeListBegin(facebook::thrift::protocol::T_STRUCT, (*(this->rowBatches)).size());
    std::vector<BatchMutation> ::const_iterator _iter107;
    for (_iter107 = (*(this->rowBatches)).begin(); _iter107 != (*(this->rowBatches)).end(); ++_iter107)
    {
      xfer += (*_iter107).write(oprot);
    }
    xfer += oprot->writeListEnd();
  }
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("timestamp", facebook::thrift::protocol::T_I64, 3);
  xfer += oprot->writeI64((*(this->timestamp)));
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_mutateRowsTs_result::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->io.read(iprot);
          this->__isset.io = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 2:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->ia.read(iprot);
          this->__isset.ia = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_mutateRowsTs_result::write(facebook::thrift::protocol::TProtocol* oprot) const {

  uint32_t xfer = 0;

  xfer += oprot->writeStructBegin("Hbase_mutateRowsTs_result");

  if (this->__isset.io) {
    xfer += oprot->writeFieldBegin("io", facebook::thrift::protocol::T_STRUCT, 1);
    xfer += this->io.write(oprot);
    xfer += oprot->writeFieldEnd();
  } else if (this->__isset.ia) {
    xfer += oprot->writeFieldBegin("ia", facebook::thrift::protocol::T_STRUCT, 2);
    xfer += this->ia.write(oprot);
    xfer += oprot->writeFieldEnd();
  }
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_mutateRowsTs_presult::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->io.read(iprot);
          this->__isset.io = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 2:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->ia.read(iprot);
          this->__isset.ia = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_deleteAll_args::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRING) {
          xfer += iprot->readBinary(this->tableName);
          this->__isset.tableName = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 2:
        if (ftype == facebook::thrift::protocol::T_STRING) {
          xfer += iprot->readBinary(this->row);
          this->__isset.row = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 3:
        if (ftype == facebook::thrift::protocol::T_STRING) {
          xfer += iprot->readBinary(this->column);
          this->__isset.column = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_deleteAll_args::write(facebook::thrift::protocol::TProtocol* oprot) const {
  uint32_t xfer = 0;
  xfer += oprot->writeStructBegin("Hbase_deleteAll_args");
  xfer += oprot->writeFieldBegin("tableName", facebook::thrift::protocol::T_STRING, 1);
  xfer += oprot->writeBinary(this->tableName);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("row", facebook::thrift::protocol::T_STRING, 2);
  xfer += oprot->writeBinary(this->row);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("column", facebook::thrift::protocol::T_STRING, 3);
  xfer += oprot->writeBinary(this->column);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_deleteAll_pargs::write(facebook::thrift::protocol::TProtocol* oprot) const {
  uint32_t xfer = 0;
  xfer += oprot->writeStructBegin("Hbase_deleteAll_pargs");
  xfer += oprot->writeFieldBegin("tableName", facebook::thrift::protocol::T_STRING, 1);
  xfer += oprot->writeBinary((*(this->tableName)));
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("row", facebook::thrift::protocol::T_STRING, 2);
  xfer += oprot->writeBinary((*(this->row)));
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("column", facebook::thrift::protocol::T_STRING, 3);
  xfer += oprot->writeBinary((*(this->column)));
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_deleteAll_result::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->io.read(iprot);
          this->__isset.io = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_deleteAll_result::write(facebook::thrift::protocol::TProtocol* oprot) const {

  uint32_t xfer = 0;

  xfer += oprot->writeStructBegin("Hbase_deleteAll_result");

  if (this->__isset.io) {
    xfer += oprot->writeFieldBegin("io", facebook::thrift::protocol::T_STRUCT, 1);
    xfer += this->io.write(oprot);
    xfer += oprot->writeFieldEnd();
  }
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_deleteAll_presult::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->io.read(iprot);
          this->__isset.io = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_deleteAllTs_args::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRING) {
          xfer += iprot->readBinary(this->tableName);
          this->__isset.tableName = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 2:
        if (ftype == facebook::thrift::protocol::T_STRING) {
          xfer += iprot->readBinary(this->row);
          this->__isset.row = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 3:
        if (ftype == facebook::thrift::protocol::T_STRING) {
          xfer += iprot->readBinary(this->column);
          this->__isset.column = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 4:
        if (ftype == facebook::thrift::protocol::T_I64) {
          xfer += iprot->readI64(this->timestamp);
          this->__isset.timestamp = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_deleteAllTs_args::write(facebook::thrift::protocol::TProtocol* oprot) const {
  uint32_t xfer = 0;
  xfer += oprot->writeStructBegin("Hbase_deleteAllTs_args");
  xfer += oprot->writeFieldBegin("tableName", facebook::thrift::protocol::T_STRING, 1);
  xfer += oprot->writeBinary(this->tableName);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("row", facebook::thrift::protocol::T_STRING, 2);
  xfer += oprot->writeBinary(this->row);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("column", facebook::thrift::protocol::T_STRING, 3);
  xfer += oprot->writeBinary(this->column);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("timestamp", facebook::thrift::protocol::T_I64, 4);
  xfer += oprot->writeI64(this->timestamp);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_deleteAllTs_pargs::write(facebook::thrift::protocol::TProtocol* oprot) const {
  uint32_t xfer = 0;
  xfer += oprot->writeStructBegin("Hbase_deleteAllTs_pargs");
  xfer += oprot->writeFieldBegin("tableName", facebook::thrift::protocol::T_STRING, 1);
  xfer += oprot->writeBinary((*(this->tableName)));
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("row", facebook::thrift::protocol::T_STRING, 2);
  xfer += oprot->writeBinary((*(this->row)));
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("column", facebook::thrift::protocol::T_STRING, 3);
  xfer += oprot->writeBinary((*(this->column)));
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("timestamp", facebook::thrift::protocol::T_I64, 4);
  xfer += oprot->writeI64((*(this->timestamp)));
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_deleteAllTs_result::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->io.read(iprot);
          this->__isset.io = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_deleteAllTs_result::write(facebook::thrift::protocol::TProtocol* oprot) const {

  uint32_t xfer = 0;

  xfer += oprot->writeStructBegin("Hbase_deleteAllTs_result");

  if (this->__isset.io) {
    xfer += oprot->writeFieldBegin("io", facebook::thrift::protocol::T_STRUCT, 1);
    xfer += this->io.write(oprot);
    xfer += oprot->writeFieldEnd();
  }
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_deleteAllTs_presult::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->io.read(iprot);
          this->__isset.io = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_deleteAllRow_args::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRING) {
          xfer += iprot->readBinary(this->tableName);
          this->__isset.tableName = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 2:
        if (ftype == facebook::thrift::protocol::T_STRING) {
          xfer += iprot->readBinary(this->row);
          this->__isset.row = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_deleteAllRow_args::write(facebook::thrift::protocol::TProtocol* oprot) const {
  uint32_t xfer = 0;
  xfer += oprot->writeStructBegin("Hbase_deleteAllRow_args");
  xfer += oprot->writeFieldBegin("tableName", facebook::thrift::protocol::T_STRING, 1);
  xfer += oprot->writeBinary(this->tableName);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("row", facebook::thrift::protocol::T_STRING, 2);
  xfer += oprot->writeBinary(this->row);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_deleteAllRow_pargs::write(facebook::thrift::protocol::TProtocol* oprot) const {
  uint32_t xfer = 0;
  xfer += oprot->writeStructBegin("Hbase_deleteAllRow_pargs");
  xfer += oprot->writeFieldBegin("tableName", facebook::thrift::protocol::T_STRING, 1);
  xfer += oprot->writeBinary((*(this->tableName)));
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("row", facebook::thrift::protocol::T_STRING, 2);
  xfer += oprot->writeBinary((*(this->row)));
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_deleteAllRow_result::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->io.read(iprot);
          this->__isset.io = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_deleteAllRow_result::write(facebook::thrift::protocol::TProtocol* oprot) const {

  uint32_t xfer = 0;

  xfer += oprot->writeStructBegin("Hbase_deleteAllRow_result");

  if (this->__isset.io) {
    xfer += oprot->writeFieldBegin("io", facebook::thrift::protocol::T_STRUCT, 1);
    xfer += this->io.write(oprot);
    xfer += oprot->writeFieldEnd();
  }
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_deleteAllRow_presult::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->io.read(iprot);
          this->__isset.io = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_deleteAllRowTs_args::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRING) {
          xfer += iprot->readBinary(this->tableName);
          this->__isset.tableName = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 2:
        if (ftype == facebook::thrift::protocol::T_STRING) {
          xfer += iprot->readBinary(this->row);
          this->__isset.row = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 3:
        if (ftype == facebook::thrift::protocol::T_I64) {
          xfer += iprot->readI64(this->timestamp);
          this->__isset.timestamp = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_deleteAllRowTs_args::write(facebook::thrift::protocol::TProtocol* oprot) const {
  uint32_t xfer = 0;
  xfer += oprot->writeStructBegin("Hbase_deleteAllRowTs_args");
  xfer += oprot->writeFieldBegin("tableName", facebook::thrift::protocol::T_STRING, 1);
  xfer += oprot->writeBinary(this->tableName);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("row", facebook::thrift::protocol::T_STRING, 2);
  xfer += oprot->writeBinary(this->row);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("timestamp", facebook::thrift::protocol::T_I64, 3);
  xfer += oprot->writeI64(this->timestamp);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_deleteAllRowTs_pargs::write(facebook::thrift::protocol::TProtocol* oprot) const {
  uint32_t xfer = 0;
  xfer += oprot->writeStructBegin("Hbase_deleteAllRowTs_pargs");
  xfer += oprot->writeFieldBegin("tableName", facebook::thrift::protocol::T_STRING, 1);
  xfer += oprot->writeBinary((*(this->tableName)));
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("row", facebook::thrift::protocol::T_STRING, 2);
  xfer += oprot->writeBinary((*(this->row)));
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("timestamp", facebook::thrift::protocol::T_I64, 3);
  xfer += oprot->writeI64((*(this->timestamp)));
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_deleteAllRowTs_result::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->io.read(iprot);
          this->__isset.io = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_deleteAllRowTs_result::write(facebook::thrift::protocol::TProtocol* oprot) const {

  uint32_t xfer = 0;

  xfer += oprot->writeStructBegin("Hbase_deleteAllRowTs_result");

  if (this->__isset.io) {
    xfer += oprot->writeFieldBegin("io", facebook::thrift::protocol::T_STRUCT, 1);
    xfer += this->io.write(oprot);
    xfer += oprot->writeFieldEnd();
  }
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_deleteAllRowTs_presult::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->io.read(iprot);
          this->__isset.io = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_scannerOpen_args::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRING) {
          xfer += iprot->readBinary(this->tableName);
          this->__isset.tableName = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 2:
        if (ftype == facebook::thrift::protocol::T_STRING) {
          xfer += iprot->readBinary(this->startRow);
          this->__isset.startRow = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 3:
        if (ftype == facebook::thrift::protocol::T_LIST) {
          {
            this->columns.clear();
            uint32_t _size108;
            facebook::thrift::protocol::TType _etype111;
            iprot->readListBegin(_etype111, _size108);
            this->columns.resize(_size108);
            uint32_t _i112;
            for (_i112 = 0; _i112 < _size108; ++_i112)
            {
              xfer += iprot->readBinary(this->columns[_i112]);
            }
            iprot->readListEnd();
          }
          this->__isset.columns = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_scannerOpen_args::write(facebook::thrift::protocol::TProtocol* oprot) const {
  uint32_t xfer = 0;
  xfer += oprot->writeStructBegin("Hbase_scannerOpen_args");
  xfer += oprot->writeFieldBegin("tableName", facebook::thrift::protocol::T_STRING, 1);
  xfer += oprot->writeBinary(this->tableName);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("startRow", facebook::thrift::protocol::T_STRING, 2);
  xfer += oprot->writeBinary(this->startRow);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("columns", facebook::thrift::protocol::T_LIST, 3);
  {
    xfer += oprot->writeListBegin(facebook::thrift::protocol::T_STRING, this->columns.size());
    std::vector<Text> ::const_iterator _iter113;
    for (_iter113 = this->columns.begin(); _iter113 != this->columns.end(); ++_iter113)
    {
      xfer += oprot->writeBinary((*_iter113));
    }
    xfer += oprot->writeListEnd();
  }
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_scannerOpen_pargs::write(facebook::thrift::protocol::TProtocol* oprot) const {
  uint32_t xfer = 0;
  xfer += oprot->writeStructBegin("Hbase_scannerOpen_pargs");
  xfer += oprot->writeFieldBegin("tableName", facebook::thrift::protocol::T_STRING, 1);
  xfer += oprot->writeBinary((*(this->tableName)));
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("startRow", facebook::thrift::protocol::T_STRING, 2);
  xfer += oprot->writeBinary((*(this->startRow)));
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("columns", facebook::thrift::protocol::T_LIST, 3);
  {
    xfer += oprot->writeListBegin(facebook::thrift::protocol::T_STRING, (*(this->columns)).size());
    std::vector<Text> ::const_iterator _iter114;
    for (_iter114 = (*(this->columns)).begin(); _iter114 != (*(this->columns)).end(); ++_iter114)
    {
      xfer += oprot->writeBinary((*_iter114));
    }
    xfer += oprot->writeListEnd();
  }
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_scannerOpen_result::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 0:
        if (ftype == facebook::thrift::protocol::T_I32) {
          xfer += iprot->readI32(this->success);
          this->__isset.success = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->io.read(iprot);
          this->__isset.io = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_scannerOpen_result::write(facebook::thrift::protocol::TProtocol* oprot) const {

  uint32_t xfer = 0;

  xfer += oprot->writeStructBegin("Hbase_scannerOpen_result");

  if (this->__isset.success) {
    xfer += oprot->writeFieldBegin("success", facebook::thrift::protocol::T_I32, 0);
    xfer += oprot->writeI32(this->success);
    xfer += oprot->writeFieldEnd();
  } else if (this->__isset.io) {
    xfer += oprot->writeFieldBegin("io", facebook::thrift::protocol::T_STRUCT, 1);
    xfer += this->io.write(oprot);
    xfer += oprot->writeFieldEnd();
  }
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_scannerOpen_presult::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 0:
        if (ftype == facebook::thrift::protocol::T_I32) {
          xfer += iprot->readI32((*(this->success)));
          this->__isset.success = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->io.read(iprot);
          this->__isset.io = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_scannerOpenWithStop_args::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRING) {
          xfer += iprot->readBinary(this->tableName);
          this->__isset.tableName = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 2:
        if (ftype == facebook::thrift::protocol::T_STRING) {
          xfer += iprot->readBinary(this->startRow);
          this->__isset.startRow = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 3:
        if (ftype == facebook::thrift::protocol::T_STRING) {
          xfer += iprot->readBinary(this->stopRow);
          this->__isset.stopRow = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 4:
        if (ftype == facebook::thrift::protocol::T_LIST) {
          {
            this->columns.clear();
            uint32_t _size115;
            facebook::thrift::protocol::TType _etype118;
            iprot->readListBegin(_etype118, _size115);
            this->columns.resize(_size115);
            uint32_t _i119;
            for (_i119 = 0; _i119 < _size115; ++_i119)
            {
              xfer += iprot->readBinary(this->columns[_i119]);
            }
            iprot->readListEnd();
          }
          this->__isset.columns = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_scannerOpenWithStop_args::write(facebook::thrift::protocol::TProtocol* oprot) const {
  uint32_t xfer = 0;
  xfer += oprot->writeStructBegin("Hbase_scannerOpenWithStop_args");
  xfer += oprot->writeFieldBegin("tableName", facebook::thrift::protocol::T_STRING, 1);
  xfer += oprot->writeBinary(this->tableName);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("startRow", facebook::thrift::protocol::T_STRING, 2);
  xfer += oprot->writeBinary(this->startRow);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("stopRow", facebook::thrift::protocol::T_STRING, 3);
  xfer += oprot->writeBinary(this->stopRow);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("columns", facebook::thrift::protocol::T_LIST, 4);
  {
    xfer += oprot->writeListBegin(facebook::thrift::protocol::T_STRING, this->columns.size());
    std::vector<Text> ::const_iterator _iter120;
    for (_iter120 = this->columns.begin(); _iter120 != this->columns.end(); ++_iter120)
    {
      xfer += oprot->writeBinary((*_iter120));
    }
    xfer += oprot->writeListEnd();
  }
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_scannerOpenWithStop_pargs::write(facebook::thrift::protocol::TProtocol* oprot) const {
  uint32_t xfer = 0;
  xfer += oprot->writeStructBegin("Hbase_scannerOpenWithStop_pargs");
  xfer += oprot->writeFieldBegin("tableName", facebook::thrift::protocol::T_STRING, 1);
  xfer += oprot->writeBinary((*(this->tableName)));
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("startRow", facebook::thrift::protocol::T_STRING, 2);
  xfer += oprot->writeBinary((*(this->startRow)));
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("stopRow", facebook::thrift::protocol::T_STRING, 3);
  xfer += oprot->writeBinary((*(this->stopRow)));
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("columns", facebook::thrift::protocol::T_LIST, 4);
  {
    xfer += oprot->writeListBegin(facebook::thrift::protocol::T_STRING, (*(this->columns)).size());
    std::vector<Text> ::const_iterator _iter121;
    for (_iter121 = (*(this->columns)).begin(); _iter121 != (*(this->columns)).end(); ++_iter121)
    {
      xfer += oprot->writeBinary((*_iter121));
    }
    xfer += oprot->writeListEnd();
  }
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_scannerOpenWithStop_result::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 0:
        if (ftype == facebook::thrift::protocol::T_I32) {
          xfer += iprot->readI32(this->success);
          this->__isset.success = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->io.read(iprot);
          this->__isset.io = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_scannerOpenWithStop_result::write(facebook::thrift::protocol::TProtocol* oprot) const {

  uint32_t xfer = 0;

  xfer += oprot->writeStructBegin("Hbase_scannerOpenWithStop_result");

  if (this->__isset.success) {
    xfer += oprot->writeFieldBegin("success", facebook::thrift::protocol::T_I32, 0);
    xfer += oprot->writeI32(this->success);
    xfer += oprot->writeFieldEnd();
  } else if (this->__isset.io) {
    xfer += oprot->writeFieldBegin("io", facebook::thrift::protocol::T_STRUCT, 1);
    xfer += this->io.write(oprot);
    xfer += oprot->writeFieldEnd();
  }
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_scannerOpenWithStop_presult::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 0:
        if (ftype == facebook::thrift::protocol::T_I32) {
          xfer += iprot->readI32((*(this->success)));
          this->__isset.success = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->io.read(iprot);
          this->__isset.io = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_scannerOpenTs_args::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRING) {
          xfer += iprot->readBinary(this->tableName);
          this->__isset.tableName = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 2:
        if (ftype == facebook::thrift::protocol::T_STRING) {
          xfer += iprot->readBinary(this->startRow);
          this->__isset.startRow = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 3:
        if (ftype == facebook::thrift::protocol::T_LIST) {
          {
            this->columns.clear();
            uint32_t _size122;
            facebook::thrift::protocol::TType _etype125;
            iprot->readListBegin(_etype125, _size122);
            this->columns.resize(_size122);
            uint32_t _i126;
            for (_i126 = 0; _i126 < _size122; ++_i126)
            {
              xfer += iprot->readBinary(this->columns[_i126]);
            }
            iprot->readListEnd();
          }
          this->__isset.columns = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 4:
        if (ftype == facebook::thrift::protocol::T_I64) {
          xfer += iprot->readI64(this->timestamp);
          this->__isset.timestamp = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_scannerOpenTs_args::write(facebook::thrift::protocol::TProtocol* oprot) const {
  uint32_t xfer = 0;
  xfer += oprot->writeStructBegin("Hbase_scannerOpenTs_args");
  xfer += oprot->writeFieldBegin("tableName", facebook::thrift::protocol::T_STRING, 1);
  xfer += oprot->writeBinary(this->tableName);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("startRow", facebook::thrift::protocol::T_STRING, 2);
  xfer += oprot->writeBinary(this->startRow);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("columns", facebook::thrift::protocol::T_LIST, 3);
  {
    xfer += oprot->writeListBegin(facebook::thrift::protocol::T_STRING, this->columns.size());
    std::vector<Text> ::const_iterator _iter127;
    for (_iter127 = this->columns.begin(); _iter127 != this->columns.end(); ++_iter127)
    {
      xfer += oprot->writeBinary((*_iter127));
    }
    xfer += oprot->writeListEnd();
  }
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("timestamp", facebook::thrift::protocol::T_I64, 4);
  xfer += oprot->writeI64(this->timestamp);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_scannerOpenTs_pargs::write(facebook::thrift::protocol::TProtocol* oprot) const {
  uint32_t xfer = 0;
  xfer += oprot->writeStructBegin("Hbase_scannerOpenTs_pargs");
  xfer += oprot->writeFieldBegin("tableName", facebook::thrift::protocol::T_STRING, 1);
  xfer += oprot->writeBinary((*(this->tableName)));
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("startRow", facebook::thrift::protocol::T_STRING, 2);
  xfer += oprot->writeBinary((*(this->startRow)));
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("columns", facebook::thrift::protocol::T_LIST, 3);
  {
    xfer += oprot->writeListBegin(facebook::thrift::protocol::T_STRING, (*(this->columns)).size());
    std::vector<Text> ::const_iterator _iter128;
    for (_iter128 = (*(this->columns)).begin(); _iter128 != (*(this->columns)).end(); ++_iter128)
    {
      xfer += oprot->writeBinary((*_iter128));
    }
    xfer += oprot->writeListEnd();
  }
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("timestamp", facebook::thrift::protocol::T_I64, 4);
  xfer += oprot->writeI64((*(this->timestamp)));
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_scannerOpenTs_result::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 0:
        if (ftype == facebook::thrift::protocol::T_I32) {
          xfer += iprot->readI32(this->success);
          this->__isset.success = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->io.read(iprot);
          this->__isset.io = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_scannerOpenTs_result::write(facebook::thrift::protocol::TProtocol* oprot) const {

  uint32_t xfer = 0;

  xfer += oprot->writeStructBegin("Hbase_scannerOpenTs_result");

  if (this->__isset.success) {
    xfer += oprot->writeFieldBegin("success", facebook::thrift::protocol::T_I32, 0);
    xfer += oprot->writeI32(this->success);
    xfer += oprot->writeFieldEnd();
  } else if (this->__isset.io) {
    xfer += oprot->writeFieldBegin("io", facebook::thrift::protocol::T_STRUCT, 1);
    xfer += this->io.write(oprot);
    xfer += oprot->writeFieldEnd();
  }
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_scannerOpenTs_presult::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 0:
        if (ftype == facebook::thrift::protocol::T_I32) {
          xfer += iprot->readI32((*(this->success)));
          this->__isset.success = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->io.read(iprot);
          this->__isset.io = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_scannerOpenWithStopTs_args::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRING) {
          xfer += iprot->readBinary(this->tableName);
          this->__isset.tableName = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 2:
        if (ftype == facebook::thrift::protocol::T_STRING) {
          xfer += iprot->readBinary(this->startRow);
          this->__isset.startRow = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 3:
        if (ftype == facebook::thrift::protocol::T_STRING) {
          xfer += iprot->readBinary(this->stopRow);
          this->__isset.stopRow = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 4:
        if (ftype == facebook::thrift::protocol::T_LIST) {
          {
            this->columns.clear();
            uint32_t _size129;
            facebook::thrift::protocol::TType _etype132;
            iprot->readListBegin(_etype132, _size129);
            this->columns.resize(_size129);
            uint32_t _i133;
            for (_i133 = 0; _i133 < _size129; ++_i133)
            {
              xfer += iprot->readBinary(this->columns[_i133]);
            }
            iprot->readListEnd();
          }
          this->__isset.columns = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 5:
        if (ftype == facebook::thrift::protocol::T_I64) {
          xfer += iprot->readI64(this->timestamp);
          this->__isset.timestamp = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_scannerOpenWithStopTs_args::write(facebook::thrift::protocol::TProtocol* oprot) const {
  uint32_t xfer = 0;
  xfer += oprot->writeStructBegin("Hbase_scannerOpenWithStopTs_args");
  xfer += oprot->writeFieldBegin("tableName", facebook::thrift::protocol::T_STRING, 1);
  xfer += oprot->writeBinary(this->tableName);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("startRow", facebook::thrift::protocol::T_STRING, 2);
  xfer += oprot->writeBinary(this->startRow);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("stopRow", facebook::thrift::protocol::T_STRING, 3);
  xfer += oprot->writeBinary(this->stopRow);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("columns", facebook::thrift::protocol::T_LIST, 4);
  {
    xfer += oprot->writeListBegin(facebook::thrift::protocol::T_STRING, this->columns.size());
    std::vector<Text> ::const_iterator _iter134;
    for (_iter134 = this->columns.begin(); _iter134 != this->columns.end(); ++_iter134)
    {
      xfer += oprot->writeBinary((*_iter134));
    }
    xfer += oprot->writeListEnd();
  }
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("timestamp", facebook::thrift::protocol::T_I64, 5);
  xfer += oprot->writeI64(this->timestamp);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_scannerOpenWithStopTs_pargs::write(facebook::thrift::protocol::TProtocol* oprot) const {
  uint32_t xfer = 0;
  xfer += oprot->writeStructBegin("Hbase_scannerOpenWithStopTs_pargs");
  xfer += oprot->writeFieldBegin("tableName", facebook::thrift::protocol::T_STRING, 1);
  xfer += oprot->writeBinary((*(this->tableName)));
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("startRow", facebook::thrift::protocol::T_STRING, 2);
  xfer += oprot->writeBinary((*(this->startRow)));
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("stopRow", facebook::thrift::protocol::T_STRING, 3);
  xfer += oprot->writeBinary((*(this->stopRow)));
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("columns", facebook::thrift::protocol::T_LIST, 4);
  {
    xfer += oprot->writeListBegin(facebook::thrift::protocol::T_STRING, (*(this->columns)).size());
    std::vector<Text> ::const_iterator _iter135;
    for (_iter135 = (*(this->columns)).begin(); _iter135 != (*(this->columns)).end(); ++_iter135)
    {
      xfer += oprot->writeBinary((*_iter135));
    }
    xfer += oprot->writeListEnd();
  }
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("timestamp", facebook::thrift::protocol::T_I64, 5);
  xfer += oprot->writeI64((*(this->timestamp)));
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_scannerOpenWithStopTs_result::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 0:
        if (ftype == facebook::thrift::protocol::T_I32) {
          xfer += iprot->readI32(this->success);
          this->__isset.success = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->io.read(iprot);
          this->__isset.io = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_scannerOpenWithStopTs_result::write(facebook::thrift::protocol::TProtocol* oprot) const {

  uint32_t xfer = 0;

  xfer += oprot->writeStructBegin("Hbase_scannerOpenWithStopTs_result");

  if (this->__isset.success) {
    xfer += oprot->writeFieldBegin("success", facebook::thrift::protocol::T_I32, 0);
    xfer += oprot->writeI32(this->success);
    xfer += oprot->writeFieldEnd();
  } else if (this->__isset.io) {
    xfer += oprot->writeFieldBegin("io", facebook::thrift::protocol::T_STRUCT, 1);
    xfer += this->io.write(oprot);
    xfer += oprot->writeFieldEnd();
  }
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_scannerOpenWithStopTs_presult::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 0:
        if (ftype == facebook::thrift::protocol::T_I32) {
          xfer += iprot->readI32((*(this->success)));
          this->__isset.success = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->io.read(iprot);
          this->__isset.io = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_scannerGet_args::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
        if (ftype == facebook::thrift::protocol::T_I32) {
          xfer += iprot->readI32(this->id);
          this->__isset.id = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_scannerGet_args::write(facebook::thrift::protocol::TProtocol* oprot) const {
  uint32_t xfer = 0;
  xfer += oprot->writeStructBegin("Hbase_scannerGet_args");
  xfer += oprot->writeFieldBegin("id", facebook::thrift::protocol::T_I32, 1);
  xfer += oprot->writeI32(this->id);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_scannerGet_pargs::write(facebook::thrift::protocol::TProtocol* oprot) const {
  uint32_t xfer = 0;
  xfer += oprot->writeStructBegin("Hbase_scannerGet_pargs");
  xfer += oprot->writeFieldBegin("id", facebook::thrift::protocol::T_I32, 1);
  xfer += oprot->writeI32((*(this->id)));
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_scannerGet_result::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 0:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->success.read(iprot);
          this->__isset.success = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->io.read(iprot);
          this->__isset.io = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 2:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->ia.read(iprot);
          this->__isset.ia = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 3:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->nf.read(iprot);
          this->__isset.nf = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_scannerGet_result::write(facebook::thrift::protocol::TProtocol* oprot) const {

  uint32_t xfer = 0;

  xfer += oprot->writeStructBegin("Hbase_scannerGet_result");

  if (this->__isset.success) {
    xfer += oprot->writeFieldBegin("success", facebook::thrift::protocol::T_STRUCT, 0);
    xfer += this->success.write(oprot);
    xfer += oprot->writeFieldEnd();
  } else if (this->__isset.io) {
    xfer += oprot->writeFieldBegin("io", facebook::thrift::protocol::T_STRUCT, 1);
    xfer += this->io.write(oprot);
    xfer += oprot->writeFieldEnd();
  } else if (this->__isset.ia) {
    xfer += oprot->writeFieldBegin("ia", facebook::thrift::protocol::T_STRUCT, 2);
    xfer += this->ia.write(oprot);
    xfer += oprot->writeFieldEnd();
  } else if (this->__isset.nf) {
    xfer += oprot->writeFieldBegin("nf", facebook::thrift::protocol::T_STRUCT, 3);
    xfer += this->nf.write(oprot);
    xfer += oprot->writeFieldEnd();
  }
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_scannerGet_presult::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 0:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += (*(this->success)).read(iprot);
          this->__isset.success = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->io.read(iprot);
          this->__isset.io = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 2:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->ia.read(iprot);
          this->__isset.ia = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 3:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->nf.read(iprot);
          this->__isset.nf = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_scannerClose_args::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
        if (ftype == facebook::thrift::protocol::T_I32) {
          xfer += iprot->readI32(this->id);
          this->__isset.id = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_scannerClose_args::write(facebook::thrift::protocol::TProtocol* oprot) const {
  uint32_t xfer = 0;
  xfer += oprot->writeStructBegin("Hbase_scannerClose_args");
  xfer += oprot->writeFieldBegin("id", facebook::thrift::protocol::T_I32, 1);
  xfer += oprot->writeI32(this->id);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_scannerClose_pargs::write(facebook::thrift::protocol::TProtocol* oprot) const {
  uint32_t xfer = 0;
  xfer += oprot->writeStructBegin("Hbase_scannerClose_pargs");
  xfer += oprot->writeFieldBegin("id", facebook::thrift::protocol::T_I32, 1);
  xfer += oprot->writeI32((*(this->id)));
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_scannerClose_result::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->io.read(iprot);
          this->__isset.io = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 2:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->ia.read(iprot);
          this->__isset.ia = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

uint32_t Hbase_scannerClose_result::write(facebook::thrift::protocol::TProtocol* oprot) const {

  uint32_t xfer = 0;

  xfer += oprot->writeStructBegin("Hbase_scannerClose_result");

  if (this->__isset.io) {
    xfer += oprot->writeFieldBegin("io", facebook::thrift::protocol::T_STRUCT, 1);
    xfer += this->io.write(oprot);
    xfer += oprot->writeFieldEnd();
  } else if (this->__isset.ia) {
    xfer += oprot->writeFieldBegin("ia", facebook::thrift::protocol::T_STRUCT, 2);
    xfer += this->ia.write(oprot);
    xfer += oprot->writeFieldEnd();
  }
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

uint32_t Hbase_scannerClose_presult::read(facebook::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  facebook::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using facebook::thrift::protocol::TProtocolException;


  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == facebook::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->io.read(iprot);
          this->__isset.io = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 2:
        if (ftype == facebook::thrift::protocol::T_STRUCT) {
          xfer += this->ia.read(iprot);
          this->__isset.ia = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  return xfer;
}

void HbaseClient::enableTable(const Bytes& tableName)
{
  send_enableTable(tableName);
  recv_enableTable();
}

void HbaseClient::send_enableTable(const Bytes& tableName)
{
  int32_t cseqid = 0;
  oprot_->writeMessageBegin("enableTable", facebook::thrift::protocol::T_CALL, cseqid);

  Hbase_enableTable_pargs args;
  args.tableName = &tableName;
  args.write(oprot_);

  oprot_->writeMessageEnd();
  oprot_->getTransport()->flush();
  oprot_->getTransport()->writeEnd();
}

void HbaseClient::recv_enableTable()
{

  int32_t rseqid = 0;
  std::string fname;
  facebook::thrift::protocol::TMessageType mtype;

  iprot_->readMessageBegin(fname, mtype, rseqid);
  if (mtype == facebook::thrift::protocol::T_EXCEPTION) {
    facebook::thrift::TApplicationException x;
    x.read(iprot_);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw x;
  }
  if (mtype != facebook::thrift::protocol::T_REPLY) {
    iprot_->skip(facebook::thrift::protocol::T_STRUCT);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
  }
  if (fname.compare("enableTable") != 0) {
    iprot_->skip(facebook::thrift::protocol::T_STRUCT);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::WRONG_METHOD_NAME);
  }
  Hbase_enableTable_presult result;
  result.read(iprot_);
  iprot_->readMessageEnd();
  iprot_->getTransport()->readEnd();

  if (result.__isset.io) {
    throw result.io;
  }
  return;
}

void HbaseClient::disableTable(const Bytes& tableName)
{
  send_disableTable(tableName);
  recv_disableTable();
}

void HbaseClient::send_disableTable(const Bytes& tableName)
{
  int32_t cseqid = 0;
  oprot_->writeMessageBegin("disableTable", facebook::thrift::protocol::T_CALL, cseqid);

  Hbase_disableTable_pargs args;
  args.tableName = &tableName;
  args.write(oprot_);

  oprot_->writeMessageEnd();
  oprot_->getTransport()->flush();
  oprot_->getTransport()->writeEnd();
}

void HbaseClient::recv_disableTable()
{

  int32_t rseqid = 0;
  std::string fname;
  facebook::thrift::protocol::TMessageType mtype;

  iprot_->readMessageBegin(fname, mtype, rseqid);
  if (mtype == facebook::thrift::protocol::T_EXCEPTION) {
    facebook::thrift::TApplicationException x;
    x.read(iprot_);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw x;
  }
  if (mtype != facebook::thrift::protocol::T_REPLY) {
    iprot_->skip(facebook::thrift::protocol::T_STRUCT);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
  }
  if (fname.compare("disableTable") != 0) {
    iprot_->skip(facebook::thrift::protocol::T_STRUCT);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::WRONG_METHOD_NAME);
  }
  Hbase_disableTable_presult result;
  result.read(iprot_);
  iprot_->readMessageEnd();
  iprot_->getTransport()->readEnd();

  if (result.__isset.io) {
    throw result.io;
  }
  return;
}

bool HbaseClient::isTableEnabled(const Bytes& tableName)
{
  send_isTableEnabled(tableName);
  return recv_isTableEnabled();
}

void HbaseClient::send_isTableEnabled(const Bytes& tableName)
{
  int32_t cseqid = 0;
  oprot_->writeMessageBegin("isTableEnabled", facebook::thrift::protocol::T_CALL, cseqid);

  Hbase_isTableEnabled_pargs args;
  args.tableName = &tableName;
  args.write(oprot_);

  oprot_->writeMessageEnd();
  oprot_->getTransport()->flush();
  oprot_->getTransport()->writeEnd();
}

bool HbaseClient::recv_isTableEnabled()
{

  int32_t rseqid = 0;
  std::string fname;
  facebook::thrift::protocol::TMessageType mtype;

  iprot_->readMessageBegin(fname, mtype, rseqid);
  if (mtype == facebook::thrift::protocol::T_EXCEPTION) {
    facebook::thrift::TApplicationException x;
    x.read(iprot_);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw x;
  }
  if (mtype != facebook::thrift::protocol::T_REPLY) {
    iprot_->skip(facebook::thrift::protocol::T_STRUCT);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
  }
  if (fname.compare("isTableEnabled") != 0) {
    iprot_->skip(facebook::thrift::protocol::T_STRUCT);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::WRONG_METHOD_NAME);
  }
  bool _return;
  Hbase_isTableEnabled_presult result;
  result.success = &_return;
  result.read(iprot_);
  iprot_->readMessageEnd();
  iprot_->getTransport()->readEnd();

  if (result.__isset.success) {
    return _return;
  }
  if (result.__isset.io) {
    throw result.io;
  }
  throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::MISSING_RESULT, "isTableEnabled failed: unknown result");
}

void HbaseClient::getTableNames(std::vector<Text> & _return)
{
  send_getTableNames();
  recv_getTableNames(_return);
}

void HbaseClient::send_getTableNames()
{
  int32_t cseqid = 0;
  oprot_->writeMessageBegin("getTableNames", facebook::thrift::protocol::T_CALL, cseqid);

  Hbase_getTableNames_pargs args;
  args.write(oprot_);

  oprot_->writeMessageEnd();
  oprot_->getTransport()->flush();
  oprot_->getTransport()->writeEnd();
}

void HbaseClient::recv_getTableNames(std::vector<Text> & _return)
{

  int32_t rseqid = 0;
  std::string fname;
  facebook::thrift::protocol::TMessageType mtype;

  iprot_->readMessageBegin(fname, mtype, rseqid);
  if (mtype == facebook::thrift::protocol::T_EXCEPTION) {
    facebook::thrift::TApplicationException x;
    x.read(iprot_);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw x;
  }
  if (mtype != facebook::thrift::protocol::T_REPLY) {
    iprot_->skip(facebook::thrift::protocol::T_STRUCT);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
  }
  if (fname.compare("getTableNames") != 0) {
    iprot_->skip(facebook::thrift::protocol::T_STRUCT);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::WRONG_METHOD_NAME);
  }
  Hbase_getTableNames_presult result;
  result.success = &_return;
  result.read(iprot_);
  iprot_->readMessageEnd();
  iprot_->getTransport()->readEnd();

  if (result.__isset.success) {
    // _return pointer has now been filled
    return;
  }
  if (result.__isset.io) {
    throw result.io;
  }
  throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::MISSING_RESULT, "getTableNames failed: unknown result");
}

void HbaseClient::getColumnDescriptors(std::map<Text, ColumnDescriptor> & _return, const Text& tableName)
{
  send_getColumnDescriptors(tableName);
  recv_getColumnDescriptors(_return);
}

void HbaseClient::send_getColumnDescriptors(const Text& tableName)
{
  int32_t cseqid = 0;
  oprot_->writeMessageBegin("getColumnDescriptors", facebook::thrift::protocol::T_CALL, cseqid);

  Hbase_getColumnDescriptors_pargs args;
  args.tableName = &tableName;
  args.write(oprot_);

  oprot_->writeMessageEnd();
  oprot_->getTransport()->flush();
  oprot_->getTransport()->writeEnd();
}

void HbaseClient::recv_getColumnDescriptors(std::map<Text, ColumnDescriptor> & _return)
{

  int32_t rseqid = 0;
  std::string fname;
  facebook::thrift::protocol::TMessageType mtype;

  iprot_->readMessageBegin(fname, mtype, rseqid);
  if (mtype == facebook::thrift::protocol::T_EXCEPTION) {
    facebook::thrift::TApplicationException x;
    x.read(iprot_);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw x;
  }
  if (mtype != facebook::thrift::protocol::T_REPLY) {
    iprot_->skip(facebook::thrift::protocol::T_STRUCT);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
  }
  if (fname.compare("getColumnDescriptors") != 0) {
    iprot_->skip(facebook::thrift::protocol::T_STRUCT);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::WRONG_METHOD_NAME);
  }
  Hbase_getColumnDescriptors_presult result;
  result.success = &_return;
  result.read(iprot_);
  iprot_->readMessageEnd();
  iprot_->getTransport()->readEnd();

  if (result.__isset.success) {
    // _return pointer has now been filled
    return;
  }
  if (result.__isset.io) {
    throw result.io;
  }
  throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::MISSING_RESULT, "getColumnDescriptors failed: unknown result");
}

void HbaseClient::getTableRegions(std::vector<TRegionInfo> & _return, const Text& tableName)
{
  send_getTableRegions(tableName);
  recv_getTableRegions(_return);
}

void HbaseClient::send_getTableRegions(const Text& tableName)
{
  int32_t cseqid = 0;
  oprot_->writeMessageBegin("getTableRegions", facebook::thrift::protocol::T_CALL, cseqid);

  Hbase_getTableRegions_pargs args;
  args.tableName = &tableName;
  args.write(oprot_);

  oprot_->writeMessageEnd();
  oprot_->getTransport()->flush();
  oprot_->getTransport()->writeEnd();
}

void HbaseClient::recv_getTableRegions(std::vector<TRegionInfo> & _return)
{

  int32_t rseqid = 0;
  std::string fname;
  facebook::thrift::protocol::TMessageType mtype;

  iprot_->readMessageBegin(fname, mtype, rseqid);
  if (mtype == facebook::thrift::protocol::T_EXCEPTION) {
    facebook::thrift::TApplicationException x;
    x.read(iprot_);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw x;
  }
  if (mtype != facebook::thrift::protocol::T_REPLY) {
    iprot_->skip(facebook::thrift::protocol::T_STRUCT);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
  }
  if (fname.compare("getTableRegions") != 0) {
    iprot_->skip(facebook::thrift::protocol::T_STRUCT);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::WRONG_METHOD_NAME);
  }
  Hbase_getTableRegions_presult result;
  result.success = &_return;
  result.read(iprot_);
  iprot_->readMessageEnd();
  iprot_->getTransport()->readEnd();

  if (result.__isset.success) {
    // _return pointer has now been filled
    return;
  }
  if (result.__isset.io) {
    throw result.io;
  }
  throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::MISSING_RESULT, "getTableRegions failed: unknown result");
}

void HbaseClient::createTable(const Text& tableName, const std::vector<ColumnDescriptor> & columnFamilies)
{
  send_createTable(tableName, columnFamilies);
  recv_createTable();
}

void HbaseClient::send_createTable(const Text& tableName, const std::vector<ColumnDescriptor> & columnFamilies)
{
  int32_t cseqid = 0;
  oprot_->writeMessageBegin("createTable", facebook::thrift::protocol::T_CALL, cseqid);

  Hbase_createTable_pargs args;
  args.tableName = &tableName;
  args.columnFamilies = &columnFamilies;
  args.write(oprot_);

  oprot_->writeMessageEnd();
  oprot_->getTransport()->flush();
  oprot_->getTransport()->writeEnd();
}

void HbaseClient::recv_createTable()
{

  int32_t rseqid = 0;
  std::string fname;
  facebook::thrift::protocol::TMessageType mtype;

  iprot_->readMessageBegin(fname, mtype, rseqid);
  if (mtype == facebook::thrift::protocol::T_EXCEPTION) {
    facebook::thrift::TApplicationException x;
    x.read(iprot_);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw x;
  }
  if (mtype != facebook::thrift::protocol::T_REPLY) {
    iprot_->skip(facebook::thrift::protocol::T_STRUCT);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
  }
  if (fname.compare("createTable") != 0) {
    iprot_->skip(facebook::thrift::protocol::T_STRUCT);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::WRONG_METHOD_NAME);
  }
  Hbase_createTable_presult result;
  result.read(iprot_);
  iprot_->readMessageEnd();
  iprot_->getTransport()->readEnd();

  if (result.__isset.io) {
    throw result.io;
  }
  if (result.__isset.ia) {
    throw result.ia;
  }
  if (result.__isset.exist) {
    throw result.exist;
  }
  return;
}

void HbaseClient::deleteTable(const Text& tableName)
{
  send_deleteTable(tableName);
  recv_deleteTable();
}

void HbaseClient::send_deleteTable(const Text& tableName)
{
  int32_t cseqid = 0;
  oprot_->writeMessageBegin("deleteTable", facebook::thrift::protocol::T_CALL, cseqid);

  Hbase_deleteTable_pargs args;
  args.tableName = &tableName;
  args.write(oprot_);

  oprot_->writeMessageEnd();
  oprot_->getTransport()->flush();
  oprot_->getTransport()->writeEnd();
}

void HbaseClient::recv_deleteTable()
{

  int32_t rseqid = 0;
  std::string fname;
  facebook::thrift::protocol::TMessageType mtype;

  iprot_->readMessageBegin(fname, mtype, rseqid);
  if (mtype == facebook::thrift::protocol::T_EXCEPTION) {
    facebook::thrift::TApplicationException x;
    x.read(iprot_);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw x;
  }
  if (mtype != facebook::thrift::protocol::T_REPLY) {
    iprot_->skip(facebook::thrift::protocol::T_STRUCT);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
  }
  if (fname.compare("deleteTable") != 0) {
    iprot_->skip(facebook::thrift::protocol::T_STRUCT);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::WRONG_METHOD_NAME);
  }
  Hbase_deleteTable_presult result;
  result.read(iprot_);
  iprot_->readMessageEnd();
  iprot_->getTransport()->readEnd();

  if (result.__isset.io) {
    throw result.io;
  }
  if (result.__isset.nf) {
    throw result.nf;
  }
  return;
}

void HbaseClient::get(TCell& _return, const Text& tableName, const Text& row, const Text& column)
{
  send_get(tableName, row, column);
  recv_get(_return);
}

void HbaseClient::send_get(const Text& tableName, const Text& row, const Text& column)
{
  int32_t cseqid = 0;
  oprot_->writeMessageBegin("get", facebook::thrift::protocol::T_CALL, cseqid);

  Hbase_get_pargs args;
  args.tableName = &tableName;
  args.row = &row;
  args.column = &column;
  args.write(oprot_);

  oprot_->writeMessageEnd();
  oprot_->getTransport()->flush();
  oprot_->getTransport()->writeEnd();
}

void HbaseClient::recv_get(TCell& _return)
{

  int32_t rseqid = 0;
  std::string fname;
  facebook::thrift::protocol::TMessageType mtype;

  iprot_->readMessageBegin(fname, mtype, rseqid);
  if (mtype == facebook::thrift::protocol::T_EXCEPTION) {
    facebook::thrift::TApplicationException x;
    x.read(iprot_);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw x;
  }
  if (mtype != facebook::thrift::protocol::T_REPLY) {
    iprot_->skip(facebook::thrift::protocol::T_STRUCT);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
  }
  if (fname.compare("get") != 0) {
    iprot_->skip(facebook::thrift::protocol::T_STRUCT);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::WRONG_METHOD_NAME);
  }
  Hbase_get_presult result;
  result.success = &_return;
  result.read(iprot_);
  iprot_->readMessageEnd();
  iprot_->getTransport()->readEnd();

  if (result.__isset.success) {
    // _return pointer has now been filled
    return;
  }
  if (result.__isset.io) {
    throw result.io;
  }
  if (result.__isset.nf) {
    throw result.nf;
  }
  throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::MISSING_RESULT, "get failed: unknown result");
}

void HbaseClient::getVer(std::vector<TCell> & _return, const Text& tableName, const Text& row, const Text& column, const int32_t numVersions)
{
  send_getVer(tableName, row, column, numVersions);
  recv_getVer(_return);
}

void HbaseClient::send_getVer(const Text& tableName, const Text& row, const Text& column, const int32_t numVersions)
{
  int32_t cseqid = 0;
  oprot_->writeMessageBegin("getVer", facebook::thrift::protocol::T_CALL, cseqid);

  Hbase_getVer_pargs args;
  args.tableName = &tableName;
  args.row = &row;
  args.column = &column;
  args.numVersions = &numVersions;
  args.write(oprot_);

  oprot_->writeMessageEnd();
  oprot_->getTransport()->flush();
  oprot_->getTransport()->writeEnd();
}

void HbaseClient::recv_getVer(std::vector<TCell> & _return)
{

  int32_t rseqid = 0;
  std::string fname;
  facebook::thrift::protocol::TMessageType mtype;

  iprot_->readMessageBegin(fname, mtype, rseqid);
  if (mtype == facebook::thrift::protocol::T_EXCEPTION) {
    facebook::thrift::TApplicationException x;
    x.read(iprot_);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw x;
  }
  if (mtype != facebook::thrift::protocol::T_REPLY) {
    iprot_->skip(facebook::thrift::protocol::T_STRUCT);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
  }
  if (fname.compare("getVer") != 0) {
    iprot_->skip(facebook::thrift::protocol::T_STRUCT);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::WRONG_METHOD_NAME);
  }
  Hbase_getVer_presult result;
  result.success = &_return;
  result.read(iprot_);
  iprot_->readMessageEnd();
  iprot_->getTransport()->readEnd();

  if (result.__isset.success) {
    // _return pointer has now been filled
    return;
  }
  if (result.__isset.io) {
    throw result.io;
  }
  if (result.__isset.nf) {
    throw result.nf;
  }
  throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::MISSING_RESULT, "getVer failed: unknown result");
}

void HbaseClient::getVerTs(std::vector<TCell> & _return, const Text& tableName, const Text& row, const Text& column, const int64_t timestamp, const int32_t numVersions)
{
  send_getVerTs(tableName, row, column, timestamp, numVersions);
  recv_getVerTs(_return);
}

void HbaseClient::send_getVerTs(const Text& tableName, const Text& row, const Text& column, const int64_t timestamp, const int32_t numVersions)
{
  int32_t cseqid = 0;
  oprot_->writeMessageBegin("getVerTs", facebook::thrift::protocol::T_CALL, cseqid);

  Hbase_getVerTs_pargs args;
  args.tableName = &tableName;
  args.row = &row;
  args.column = &column;
  args.timestamp = &timestamp;
  args.numVersions = &numVersions;
  args.write(oprot_);

  oprot_->writeMessageEnd();
  oprot_->getTransport()->flush();
  oprot_->getTransport()->writeEnd();
}

void HbaseClient::recv_getVerTs(std::vector<TCell> & _return)
{

  int32_t rseqid = 0;
  std::string fname;
  facebook::thrift::protocol::TMessageType mtype;

  iprot_->readMessageBegin(fname, mtype, rseqid);
  if (mtype == facebook::thrift::protocol::T_EXCEPTION) {
    facebook::thrift::TApplicationException x;
    x.read(iprot_);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw x;
  }
  if (mtype != facebook::thrift::protocol::T_REPLY) {
    iprot_->skip(facebook::thrift::protocol::T_STRUCT);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
  }
  if (fname.compare("getVerTs") != 0) {
    iprot_->skip(facebook::thrift::protocol::T_STRUCT);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::WRONG_METHOD_NAME);
  }
  Hbase_getVerTs_presult result;
  result.success = &_return;
  result.read(iprot_);
  iprot_->readMessageEnd();
  iprot_->getTransport()->readEnd();

  if (result.__isset.success) {
    // _return pointer has now been filled
    return;
  }
  if (result.__isset.io) {
    throw result.io;
  }
  if (result.__isset.nf) {
    throw result.nf;
  }
  throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::MISSING_RESULT, "getVerTs failed: unknown result");
}

void HbaseClient::getRow(TRowResult& _return, const Text& tableName, const Text& row)
{
  send_getRow(tableName, row);
  recv_getRow(_return);
}

void HbaseClient::send_getRow(const Text& tableName, const Text& row)
{
  int32_t cseqid = 0;
  oprot_->writeMessageBegin("getRow", facebook::thrift::protocol::T_CALL, cseqid);

  Hbase_getRow_pargs args;
  args.tableName = &tableName;
  args.row = &row;
  args.write(oprot_);

  oprot_->writeMessageEnd();
  oprot_->getTransport()->flush();
  oprot_->getTransport()->writeEnd();
}

void HbaseClient::recv_getRow(TRowResult& _return)
{

  int32_t rseqid = 0;
  std::string fname;
  facebook::thrift::protocol::TMessageType mtype;

  iprot_->readMessageBegin(fname, mtype, rseqid);
  if (mtype == facebook::thrift::protocol::T_EXCEPTION) {
    facebook::thrift::TApplicationException x;
    x.read(iprot_);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw x;
  }
  if (mtype != facebook::thrift::protocol::T_REPLY) {
    iprot_->skip(facebook::thrift::protocol::T_STRUCT);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
  }
  if (fname.compare("getRow") != 0) {
    iprot_->skip(facebook::thrift::protocol::T_STRUCT);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::WRONG_METHOD_NAME);
  }
  Hbase_getRow_presult result;
  result.success = &_return;
  result.read(iprot_);
  iprot_->readMessageEnd();
  iprot_->getTransport()->readEnd();

  if (result.__isset.success) {
    // _return pointer has now been filled
    return;
  }
  if (result.__isset.io) {
    throw result.io;
  }
  throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::MISSING_RESULT, "getRow failed: unknown result");
}

void HbaseClient::getRowTs(TRowResult& _return, const Text& tableName, const Text& row, const int64_t timestamp)
{
  send_getRowTs(tableName, row, timestamp);
  recv_getRowTs(_return);
}

void HbaseClient::send_getRowTs(const Text& tableName, const Text& row, const int64_t timestamp)
{
  int32_t cseqid = 0;
  oprot_->writeMessageBegin("getRowTs", facebook::thrift::protocol::T_CALL, cseqid);

  Hbase_getRowTs_pargs args;
  args.tableName = &tableName;
  args.row = &row;
  args.timestamp = &timestamp;
  args.write(oprot_);

  oprot_->writeMessageEnd();
  oprot_->getTransport()->flush();
  oprot_->getTransport()->writeEnd();
}

void HbaseClient::recv_getRowTs(TRowResult& _return)
{

  int32_t rseqid = 0;
  std::string fname;
  facebook::thrift::protocol::TMessageType mtype;

  iprot_->readMessageBegin(fname, mtype, rseqid);
  if (mtype == facebook::thrift::protocol::T_EXCEPTION) {
    facebook::thrift::TApplicationException x;
    x.read(iprot_);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw x;
  }
  if (mtype != facebook::thrift::protocol::T_REPLY) {
    iprot_->skip(facebook::thrift::protocol::T_STRUCT);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
  }
  if (fname.compare("getRowTs") != 0) {
    iprot_->skip(facebook::thrift::protocol::T_STRUCT);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::WRONG_METHOD_NAME);
  }
  Hbase_getRowTs_presult result;
  result.success = &_return;
  result.read(iprot_);
  iprot_->readMessageEnd();
  iprot_->getTransport()->readEnd();

  if (result.__isset.success) {
    // _return pointer has now been filled
    return;
  }
  if (result.__isset.io) {
    throw result.io;
  }
  throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::MISSING_RESULT, "getRowTs failed: unknown result");
}

void HbaseClient::mutateRow(const Text& tableName, const Text& row, const std::vector<Mutation> & mutations)
{
  send_mutateRow(tableName, row, mutations);
  recv_mutateRow();
}

void HbaseClient::send_mutateRow(const Text& tableName, const Text& row, const std::vector<Mutation> & mutations)
{
  int32_t cseqid = 0;
  oprot_->writeMessageBegin("mutateRow", facebook::thrift::protocol::T_CALL, cseqid);

  Hbase_mutateRow_pargs args;
  args.tableName = &tableName;
  args.row = &row;
  args.mutations = &mutations;
  args.write(oprot_);

  oprot_->writeMessageEnd();
  oprot_->getTransport()->flush();
  oprot_->getTransport()->writeEnd();
}

void HbaseClient::recv_mutateRow()
{

  int32_t rseqid = 0;
  std::string fname;
  facebook::thrift::protocol::TMessageType mtype;

  iprot_->readMessageBegin(fname, mtype, rseqid);
  if (mtype == facebook::thrift::protocol::T_EXCEPTION) {
    facebook::thrift::TApplicationException x;
    x.read(iprot_);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw x;
  }
  if (mtype != facebook::thrift::protocol::T_REPLY) {
    iprot_->skip(facebook::thrift::protocol::T_STRUCT);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
  }
  if (fname.compare("mutateRow") != 0) {
    iprot_->skip(facebook::thrift::protocol::T_STRUCT);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::WRONG_METHOD_NAME);
  }
  Hbase_mutateRow_presult result;
  result.read(iprot_);
  iprot_->readMessageEnd();
  iprot_->getTransport()->readEnd();

  if (result.__isset.io) {
    throw result.io;
  }
  if (result.__isset.ia) {
    throw result.ia;
  }
  return;
}

void HbaseClient::mutateRowTs(const Text& tableName, const Text& row, const std::vector<Mutation> & mutations, const int64_t timestamp)
{
  send_mutateRowTs(tableName, row, mutations, timestamp);
  recv_mutateRowTs();
}

void HbaseClient::send_mutateRowTs(const Text& tableName, const Text& row, const std::vector<Mutation> & mutations, const int64_t timestamp)
{
  int32_t cseqid = 0;
  oprot_->writeMessageBegin("mutateRowTs", facebook::thrift::protocol::T_CALL, cseqid);

  Hbase_mutateRowTs_pargs args;
  args.tableName = &tableName;
  args.row = &row;
  args.mutations = &mutations;
  args.timestamp = &timestamp;
  args.write(oprot_);

  oprot_->writeMessageEnd();
  oprot_->getTransport()->flush();
  oprot_->getTransport()->writeEnd();
}

void HbaseClient::recv_mutateRowTs()
{

  int32_t rseqid = 0;
  std::string fname;
  facebook::thrift::protocol::TMessageType mtype;

  iprot_->readMessageBegin(fname, mtype, rseqid);
  if (mtype == facebook::thrift::protocol::T_EXCEPTION) {
    facebook::thrift::TApplicationException x;
    x.read(iprot_);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw x;
  }
  if (mtype != facebook::thrift::protocol::T_REPLY) {
    iprot_->skip(facebook::thrift::protocol::T_STRUCT);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
  }
  if (fname.compare("mutateRowTs") != 0) {
    iprot_->skip(facebook::thrift::protocol::T_STRUCT);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::WRONG_METHOD_NAME);
  }
  Hbase_mutateRowTs_presult result;
  result.read(iprot_);
  iprot_->readMessageEnd();
  iprot_->getTransport()->readEnd();

  if (result.__isset.io) {
    throw result.io;
  }
  if (result.__isset.ia) {
    throw result.ia;
  }
  return;
}

void HbaseClient::mutateRows(const Text& tableName, const std::vector<BatchMutation> & rowBatches)
{
  send_mutateRows(tableName, rowBatches);
  recv_mutateRows();
}

void HbaseClient::send_mutateRows(const Text& tableName, const std::vector<BatchMutation> & rowBatches)
{
  int32_t cseqid = 0;
  oprot_->writeMessageBegin("mutateRows", facebook::thrift::protocol::T_CALL, cseqid);

  Hbase_mutateRows_pargs args;
  args.tableName = &tableName;
  args.rowBatches = &rowBatches;
  args.write(oprot_);

  oprot_->writeMessageEnd();
  oprot_->getTransport()->flush();
  oprot_->getTransport()->writeEnd();
}

void HbaseClient::recv_mutateRows()
{

  int32_t rseqid = 0;
  std::string fname;
  facebook::thrift::protocol::TMessageType mtype;

  iprot_->readMessageBegin(fname, mtype, rseqid);
  if (mtype == facebook::thrift::protocol::T_EXCEPTION) {
    facebook::thrift::TApplicationException x;
    x.read(iprot_);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw x;
  }
  if (mtype != facebook::thrift::protocol::T_REPLY) {
    iprot_->skip(facebook::thrift::protocol::T_STRUCT);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
  }
  if (fname.compare("mutateRows") != 0) {
    iprot_->skip(facebook::thrift::protocol::T_STRUCT);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::WRONG_METHOD_NAME);
  }
  Hbase_mutateRows_presult result;
  result.read(iprot_);
  iprot_->readMessageEnd();
  iprot_->getTransport()->readEnd();

  if (result.__isset.io) {
    throw result.io;
  }
  if (result.__isset.ia) {
    throw result.ia;
  }
  return;
}

void HbaseClient::mutateRowsTs(const Text& tableName, const std::vector<BatchMutation> & rowBatches, const int64_t timestamp)
{
  send_mutateRowsTs(tableName, rowBatches, timestamp);
  recv_mutateRowsTs();
}

void HbaseClient::send_mutateRowsTs(const Text& tableName, const std::vector<BatchMutation> & rowBatches, const int64_t timestamp)
{
  int32_t cseqid = 0;
  oprot_->writeMessageBegin("mutateRowsTs", facebook::thrift::protocol::T_CALL, cseqid);

  Hbase_mutateRowsTs_pargs args;
  args.tableName = &tableName;
  args.rowBatches = &rowBatches;
  args.timestamp = &timestamp;
  args.write(oprot_);

  oprot_->writeMessageEnd();
  oprot_->getTransport()->flush();
  oprot_->getTransport()->writeEnd();
}

void HbaseClient::recv_mutateRowsTs()
{

  int32_t rseqid = 0;
  std::string fname;
  facebook::thrift::protocol::TMessageType mtype;

  iprot_->readMessageBegin(fname, mtype, rseqid);
  if (mtype == facebook::thrift::protocol::T_EXCEPTION) {
    facebook::thrift::TApplicationException x;
    x.read(iprot_);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw x;
  }
  if (mtype != facebook::thrift::protocol::T_REPLY) {
    iprot_->skip(facebook::thrift::protocol::T_STRUCT);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
  }
  if (fname.compare("mutateRowsTs") != 0) {
    iprot_->skip(facebook::thrift::protocol::T_STRUCT);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::WRONG_METHOD_NAME);
  }
  Hbase_mutateRowsTs_presult result;
  result.read(iprot_);
  iprot_->readMessageEnd();
  iprot_->getTransport()->readEnd();

  if (result.__isset.io) {
    throw result.io;
  }
  if (result.__isset.ia) {
    throw result.ia;
  }
  return;
}

void HbaseClient::deleteAll(const Text& tableName, const Text& row, const Text& column)
{
  send_deleteAll(tableName, row, column);
  recv_deleteAll();
}

void HbaseClient::send_deleteAll(const Text& tableName, const Text& row, const Text& column)
{
  int32_t cseqid = 0;
  oprot_->writeMessageBegin("deleteAll", facebook::thrift::protocol::T_CALL, cseqid);

  Hbase_deleteAll_pargs args;
  args.tableName = &tableName;
  args.row = &row;
  args.column = &column;
  args.write(oprot_);

  oprot_->writeMessageEnd();
  oprot_->getTransport()->flush();
  oprot_->getTransport()->writeEnd();
}

void HbaseClient::recv_deleteAll()
{

  int32_t rseqid = 0;
  std::string fname;
  facebook::thrift::protocol::TMessageType mtype;

  iprot_->readMessageBegin(fname, mtype, rseqid);
  if (mtype == facebook::thrift::protocol::T_EXCEPTION) {
    facebook::thrift::TApplicationException x;
    x.read(iprot_);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw x;
  }
  if (mtype != facebook::thrift::protocol::T_REPLY) {
    iprot_->skip(facebook::thrift::protocol::T_STRUCT);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
  }
  if (fname.compare("deleteAll") != 0) {
    iprot_->skip(facebook::thrift::protocol::T_STRUCT);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::WRONG_METHOD_NAME);
  }
  Hbase_deleteAll_presult result;
  result.read(iprot_);
  iprot_->readMessageEnd();
  iprot_->getTransport()->readEnd();

  if (result.__isset.io) {
    throw result.io;
  }
  return;
}

void HbaseClient::deleteAllTs(const Text& tableName, const Text& row, const Text& column, const int64_t timestamp)
{
  send_deleteAllTs(tableName, row, column, timestamp);
  recv_deleteAllTs();
}

void HbaseClient::send_deleteAllTs(const Text& tableName, const Text& row, const Text& column, const int64_t timestamp)
{
  int32_t cseqid = 0;
  oprot_->writeMessageBegin("deleteAllTs", facebook::thrift::protocol::T_CALL, cseqid);

  Hbase_deleteAllTs_pargs args;
  args.tableName = &tableName;
  args.row = &row;
  args.column = &column;
  args.timestamp = &timestamp;
  args.write(oprot_);

  oprot_->writeMessageEnd();
  oprot_->getTransport()->flush();
  oprot_->getTransport()->writeEnd();
}

void HbaseClient::recv_deleteAllTs()
{

  int32_t rseqid = 0;
  std::string fname;
  facebook::thrift::protocol::TMessageType mtype;

  iprot_->readMessageBegin(fname, mtype, rseqid);
  if (mtype == facebook::thrift::protocol::T_EXCEPTION) {
    facebook::thrift::TApplicationException x;
    x.read(iprot_);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw x;
  }
  if (mtype != facebook::thrift::protocol::T_REPLY) {
    iprot_->skip(facebook::thrift::protocol::T_STRUCT);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
  }
  if (fname.compare("deleteAllTs") != 0) {
    iprot_->skip(facebook::thrift::protocol::T_STRUCT);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::WRONG_METHOD_NAME);
  }
  Hbase_deleteAllTs_presult result;
  result.read(iprot_);
  iprot_->readMessageEnd();
  iprot_->getTransport()->readEnd();

  if (result.__isset.io) {
    throw result.io;
  }
  return;
}

void HbaseClient::deleteAllRow(const Text& tableName, const Text& row)
{
  send_deleteAllRow(tableName, row);
  recv_deleteAllRow();
}

void HbaseClient::send_deleteAllRow(const Text& tableName, const Text& row)
{
  int32_t cseqid = 0;
  oprot_->writeMessageBegin("deleteAllRow", facebook::thrift::protocol::T_CALL, cseqid);

  Hbase_deleteAllRow_pargs args;
  args.tableName = &tableName;
  args.row = &row;
  args.write(oprot_);

  oprot_->writeMessageEnd();
  oprot_->getTransport()->flush();
  oprot_->getTransport()->writeEnd();
}

void HbaseClient::recv_deleteAllRow()
{

  int32_t rseqid = 0;
  std::string fname;
  facebook::thrift::protocol::TMessageType mtype;

  iprot_->readMessageBegin(fname, mtype, rseqid);
  if (mtype == facebook::thrift::protocol::T_EXCEPTION) {
    facebook::thrift::TApplicationException x;
    x.read(iprot_);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw x;
  }
  if (mtype != facebook::thrift::protocol::T_REPLY) {
    iprot_->skip(facebook::thrift::protocol::T_STRUCT);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
  }
  if (fname.compare("deleteAllRow") != 0) {
    iprot_->skip(facebook::thrift::protocol::T_STRUCT);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::WRONG_METHOD_NAME);
  }
  Hbase_deleteAllRow_presult result;
  result.read(iprot_);
  iprot_->readMessageEnd();
  iprot_->getTransport()->readEnd();

  if (result.__isset.io) {
    throw result.io;
  }
  return;
}

void HbaseClient::deleteAllRowTs(const Text& tableName, const Text& row, const int64_t timestamp)
{
  send_deleteAllRowTs(tableName, row, timestamp);
  recv_deleteAllRowTs();
}

void HbaseClient::send_deleteAllRowTs(const Text& tableName, const Text& row, const int64_t timestamp)
{
  int32_t cseqid = 0;
  oprot_->writeMessageBegin("deleteAllRowTs", facebook::thrift::protocol::T_CALL, cseqid);

  Hbase_deleteAllRowTs_pargs args;
  args.tableName = &tableName;
  args.row = &row;
  args.timestamp = &timestamp;
  args.write(oprot_);

  oprot_->writeMessageEnd();
  oprot_->getTransport()->flush();
  oprot_->getTransport()->writeEnd();
}

void HbaseClient::recv_deleteAllRowTs()
{

  int32_t rseqid = 0;
  std::string fname;
  facebook::thrift::protocol::TMessageType mtype;

  iprot_->readMessageBegin(fname, mtype, rseqid);
  if (mtype == facebook::thrift::protocol::T_EXCEPTION) {
    facebook::thrift::TApplicationException x;
    x.read(iprot_);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw x;
  }
  if (mtype != facebook::thrift::protocol::T_REPLY) {
    iprot_->skip(facebook::thrift::protocol::T_STRUCT);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
  }
  if (fname.compare("deleteAllRowTs") != 0) {
    iprot_->skip(facebook::thrift::protocol::T_STRUCT);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::WRONG_METHOD_NAME);
  }
  Hbase_deleteAllRowTs_presult result;
  result.read(iprot_);
  iprot_->readMessageEnd();
  iprot_->getTransport()->readEnd();

  if (result.__isset.io) {
    throw result.io;
  }
  return;
}

ScannerID HbaseClient::scannerOpen(const Text& tableName, const Text& startRow, const std::vector<Text> & columns)
{
  send_scannerOpen(tableName, startRow, columns);
  return recv_scannerOpen();
}

void HbaseClient::send_scannerOpen(const Text& tableName, const Text& startRow, const std::vector<Text> & columns)
{
  int32_t cseqid = 0;
  oprot_->writeMessageBegin("scannerOpen", facebook::thrift::protocol::T_CALL, cseqid);

  Hbase_scannerOpen_pargs args;
  args.tableName = &tableName;
  args.startRow = &startRow;
  args.columns = &columns;
  args.write(oprot_);

  oprot_->writeMessageEnd();
  oprot_->getTransport()->flush();
  oprot_->getTransport()->writeEnd();
}

ScannerID HbaseClient::recv_scannerOpen()
{

  int32_t rseqid = 0;
  std::string fname;
  facebook::thrift::protocol::TMessageType mtype;

  iprot_->readMessageBegin(fname, mtype, rseqid);
  if (mtype == facebook::thrift::protocol::T_EXCEPTION) {
    facebook::thrift::TApplicationException x;
    x.read(iprot_);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw x;
  }
  if (mtype != facebook::thrift::protocol::T_REPLY) {
    iprot_->skip(facebook::thrift::protocol::T_STRUCT);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
  }
  if (fname.compare("scannerOpen") != 0) {
    iprot_->skip(facebook::thrift::protocol::T_STRUCT);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::WRONG_METHOD_NAME);
  }
  ScannerID _return;
  Hbase_scannerOpen_presult result;
  result.success = &_return;
  result.read(iprot_);
  iprot_->readMessageEnd();
  iprot_->getTransport()->readEnd();

  if (result.__isset.success) {
    return _return;
  }
  if (result.__isset.io) {
    throw result.io;
  }
  throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::MISSING_RESULT, "scannerOpen failed: unknown result");
}

ScannerID HbaseClient::scannerOpenWithStop(const Text& tableName, const Text& startRow, const Text& stopRow, const std::vector<Text> & columns)
{
  send_scannerOpenWithStop(tableName, startRow, stopRow, columns);
  return recv_scannerOpenWithStop();
}

void HbaseClient::send_scannerOpenWithStop(const Text& tableName, const Text& startRow, const Text& stopRow, const std::vector<Text> & columns)
{
  int32_t cseqid = 0;
  oprot_->writeMessageBegin("scannerOpenWithStop", facebook::thrift::protocol::T_CALL, cseqid);

  Hbase_scannerOpenWithStop_pargs args;
  args.tableName = &tableName;
  args.startRow = &startRow;
  args.stopRow = &stopRow;
  args.columns = &columns;
  args.write(oprot_);

  oprot_->writeMessageEnd();
  oprot_->getTransport()->flush();
  oprot_->getTransport()->writeEnd();
}

ScannerID HbaseClient::recv_scannerOpenWithStop()
{

  int32_t rseqid = 0;
  std::string fname;
  facebook::thrift::protocol::TMessageType mtype;

  iprot_->readMessageBegin(fname, mtype, rseqid);
  if (mtype == facebook::thrift::protocol::T_EXCEPTION) {
    facebook::thrift::TApplicationException x;
    x.read(iprot_);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw x;
  }
  if (mtype != facebook::thrift::protocol::T_REPLY) {
    iprot_->skip(facebook::thrift::protocol::T_STRUCT);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
  }
  if (fname.compare("scannerOpenWithStop") != 0) {
    iprot_->skip(facebook::thrift::protocol::T_STRUCT);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::WRONG_METHOD_NAME);
  }
  ScannerID _return;
  Hbase_scannerOpenWithStop_presult result;
  result.success = &_return;
  result.read(iprot_);
  iprot_->readMessageEnd();
  iprot_->getTransport()->readEnd();

  if (result.__isset.success) {
    return _return;
  }
  if (result.__isset.io) {
    throw result.io;
  }
  throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::MISSING_RESULT, "scannerOpenWithStop failed: unknown result");
}

ScannerID HbaseClient::scannerOpenTs(const Text& tableName, const Text& startRow, const std::vector<Text> & columns, const int64_t timestamp)
{
  send_scannerOpenTs(tableName, startRow, columns, timestamp);
  return recv_scannerOpenTs();
}

void HbaseClient::send_scannerOpenTs(const Text& tableName, const Text& startRow, const std::vector<Text> & columns, const int64_t timestamp)
{
  int32_t cseqid = 0;
  oprot_->writeMessageBegin("scannerOpenTs", facebook::thrift::protocol::T_CALL, cseqid);

  Hbase_scannerOpenTs_pargs args;
  args.tableName = &tableName;
  args.startRow = &startRow;
  args.columns = &columns;
  args.timestamp = &timestamp;
  args.write(oprot_);

  oprot_->writeMessageEnd();
  oprot_->getTransport()->flush();
  oprot_->getTransport()->writeEnd();
}

ScannerID HbaseClient::recv_scannerOpenTs()
{

  int32_t rseqid = 0;
  std::string fname;
  facebook::thrift::protocol::TMessageType mtype;

  iprot_->readMessageBegin(fname, mtype, rseqid);
  if (mtype == facebook::thrift::protocol::T_EXCEPTION) {
    facebook::thrift::TApplicationException x;
    x.read(iprot_);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw x;
  }
  if (mtype != facebook::thrift::protocol::T_REPLY) {
    iprot_->skip(facebook::thrift::protocol::T_STRUCT);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
  }
  if (fname.compare("scannerOpenTs") != 0) {
    iprot_->skip(facebook::thrift::protocol::T_STRUCT);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::WRONG_METHOD_NAME);
  }
  ScannerID _return;
  Hbase_scannerOpenTs_presult result;
  result.success = &_return;
  result.read(iprot_);
  iprot_->readMessageEnd();
  iprot_->getTransport()->readEnd();

  if (result.__isset.success) {
    return _return;
  }
  if (result.__isset.io) {
    throw result.io;
  }
  throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::MISSING_RESULT, "scannerOpenTs failed: unknown result");
}

ScannerID HbaseClient::scannerOpenWithStopTs(const Text& tableName, const Text& startRow, const Text& stopRow, const std::vector<Text> & columns, const int64_t timestamp)
{
  send_scannerOpenWithStopTs(tableName, startRow, stopRow, columns, timestamp);
  return recv_scannerOpenWithStopTs();
}

void HbaseClient::send_scannerOpenWithStopTs(const Text& tableName, const Text& startRow, const Text& stopRow, const std::vector<Text> & columns, const int64_t timestamp)
{
  int32_t cseqid = 0;
  oprot_->writeMessageBegin("scannerOpenWithStopTs", facebook::thrift::protocol::T_CALL, cseqid);

  Hbase_scannerOpenWithStopTs_pargs args;
  args.tableName = &tableName;
  args.startRow = &startRow;
  args.stopRow = &stopRow;
  args.columns = &columns;
  args.timestamp = &timestamp;
  args.write(oprot_);

  oprot_->writeMessageEnd();
  oprot_->getTransport()->flush();
  oprot_->getTransport()->writeEnd();
}

ScannerID HbaseClient::recv_scannerOpenWithStopTs()
{

  int32_t rseqid = 0;
  std::string fname;
  facebook::thrift::protocol::TMessageType mtype;

  iprot_->readMessageBegin(fname, mtype, rseqid);
  if (mtype == facebook::thrift::protocol::T_EXCEPTION) {
    facebook::thrift::TApplicationException x;
    x.read(iprot_);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw x;
  }
  if (mtype != facebook::thrift::protocol::T_REPLY) {
    iprot_->skip(facebook::thrift::protocol::T_STRUCT);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
  }
  if (fname.compare("scannerOpenWithStopTs") != 0) {
    iprot_->skip(facebook::thrift::protocol::T_STRUCT);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::WRONG_METHOD_NAME);
  }
  ScannerID _return;
  Hbase_scannerOpenWithStopTs_presult result;
  result.success = &_return;
  result.read(iprot_);
  iprot_->readMessageEnd();
  iprot_->getTransport()->readEnd();

  if (result.__isset.success) {
    return _return;
  }
  if (result.__isset.io) {
    throw result.io;
  }
  throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::MISSING_RESULT, "scannerOpenWithStopTs failed: unknown result");
}

void HbaseClient::scannerGet(TRowResult& _return, const ScannerID id)
{
  send_scannerGet(id);
  recv_scannerGet(_return);
}

void HbaseClient::send_scannerGet(const ScannerID id)
{
  int32_t cseqid = 0;
  oprot_->writeMessageBegin("scannerGet", facebook::thrift::protocol::T_CALL, cseqid);

  Hbase_scannerGet_pargs args;
  args.id = &id;
  args.write(oprot_);

  oprot_->writeMessageEnd();
  oprot_->getTransport()->flush();
  oprot_->getTransport()->writeEnd();
}

void HbaseClient::recv_scannerGet(TRowResult& _return)
{

  int32_t rseqid = 0;
  std::string fname;
  facebook::thrift::protocol::TMessageType mtype;

  iprot_->readMessageBegin(fname, mtype, rseqid);
  if (mtype == facebook::thrift::protocol::T_EXCEPTION) {
    facebook::thrift::TApplicationException x;
    x.read(iprot_);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw x;
  }
  if (mtype != facebook::thrift::protocol::T_REPLY) {
    iprot_->skip(facebook::thrift::protocol::T_STRUCT);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
  }
  if (fname.compare("scannerGet") != 0) {
    iprot_->skip(facebook::thrift::protocol::T_STRUCT);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::WRONG_METHOD_NAME);
  }
  Hbase_scannerGet_presult result;
  result.success = &_return;
  result.read(iprot_);
  iprot_->readMessageEnd();
  iprot_->getTransport()->readEnd();

  if (result.__isset.success) {
    // _return pointer has now been filled
    return;
  }
  if (result.__isset.io) {
    throw result.io;
  }
  if (result.__isset.ia) {
    throw result.ia;
  }
  if (result.__isset.nf) {
    throw result.nf;
  }
  throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::MISSING_RESULT, "scannerGet failed: unknown result");
}

void HbaseClient::scannerClose(const ScannerID id)
{
  send_scannerClose(id);
  recv_scannerClose();
}

void HbaseClient::send_scannerClose(const ScannerID id)
{
  int32_t cseqid = 0;
  oprot_->writeMessageBegin("scannerClose", facebook::thrift::protocol::T_CALL, cseqid);

  Hbase_scannerClose_pargs args;
  args.id = &id;
  args.write(oprot_);

  oprot_->writeMessageEnd();
  oprot_->getTransport()->flush();
  oprot_->getTransport()->writeEnd();
}

void HbaseClient::recv_scannerClose()
{

  int32_t rseqid = 0;
  std::string fname;
  facebook::thrift::protocol::TMessageType mtype;

  iprot_->readMessageBegin(fname, mtype, rseqid);
  if (mtype == facebook::thrift::protocol::T_EXCEPTION) {
    facebook::thrift::TApplicationException x;
    x.read(iprot_);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw x;
  }
  if (mtype != facebook::thrift::protocol::T_REPLY) {
    iprot_->skip(facebook::thrift::protocol::T_STRUCT);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
  }
  if (fname.compare("scannerClose") != 0) {
    iprot_->skip(facebook::thrift::protocol::T_STRUCT);
    iprot_->readMessageEnd();
    iprot_->getTransport()->readEnd();
    throw facebook::thrift::TApplicationException(facebook::thrift::TApplicationException::WRONG_METHOD_NAME);
  }
  Hbase_scannerClose_presult result;
  result.read(iprot_);
  iprot_->readMessageEnd();
  iprot_->getTransport()->readEnd();

  if (result.__isset.io) {
    throw result.io;
  }
  if (result.__isset.ia) {
    throw result.ia;
  }
  return;
}

bool HbaseProcessor::process(boost::shared_ptr<facebook::thrift::protocol::TProtocol> piprot, boost::shared_ptr<facebook::thrift::protocol::TProtocol> poprot) {

  facebook::thrift::protocol::TProtocol* iprot = piprot.get();
  facebook::thrift::protocol::TProtocol* oprot = poprot.get();
  std::string fname;
  facebook::thrift::protocol::TMessageType mtype;
  int32_t seqid;

  iprot->readMessageBegin(fname, mtype, seqid);

  if (mtype != facebook::thrift::protocol::T_CALL) {
    iprot->skip(facebook::thrift::protocol::T_STRUCT);
    iprot->readMessageEnd();
    iprot->getTransport()->readEnd();
    facebook::thrift::TApplicationException x(facebook::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
    oprot->writeMessageBegin(fname, facebook::thrift::protocol::T_EXCEPTION, seqid);
    x.write(oprot);
    oprot->writeMessageEnd();
    oprot->getTransport()->flush();
    oprot->getTransport()->writeEnd();
    return true;
  }

  return process_fn(iprot, oprot, fname, seqid);
}

bool HbaseProcessor::process_fn(facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot, std::string& fname, int32_t seqid) {
  std::map<std::string, void (HbaseProcessor::*)(int32_t, facebook::thrift::protocol::TProtocol*, facebook::thrift::protocol::TProtocol*)>::iterator pfn;
  pfn = processMap_.find(fname);
  if (pfn == processMap_.end()) {
    iprot->skip(facebook::thrift::protocol::T_STRUCT);
    iprot->readMessageEnd();
    iprot->getTransport()->readEnd();
    facebook::thrift::TApplicationException x(facebook::thrift::TApplicationException::UNKNOWN_METHOD, "Invalid method name: '"+fname+"'");
    oprot->writeMessageBegin(fname, facebook::thrift::protocol::T_EXCEPTION, seqid);
    x.write(oprot);
    oprot->writeMessageEnd();
    oprot->getTransport()->flush();
    oprot->getTransport()->writeEnd();
    return true;
  }
  (this->*(pfn->second))(seqid, iprot, oprot);
  return true;
}

void HbaseProcessor::process_enableTable(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot)
{
  Hbase_enableTable_args args;
  args.read(iprot);
  iprot->readMessageEnd();
  iprot->getTransport()->readEnd();

  Hbase_enableTable_result result;
  try {
    iface_->enableTable(args.tableName);
  } catch (IOError &io) {
    result.io = io;
    result.__isset.io = true;
  } catch (const std::exception& e) {
    facebook::thrift::TApplicationException x(e.what());
    oprot->writeMessageBegin("enableTable", facebook::thrift::protocol::T_EXCEPTION, seqid);
    x.write(oprot);
    oprot->writeMessageEnd();
    oprot->getTransport()->flush();
    oprot->getTransport()->writeEnd();
    return;
  }

  oprot->writeMessageBegin("enableTable", facebook::thrift::protocol::T_REPLY, seqid);
  result.write(oprot);
  oprot->writeMessageEnd();
  oprot->getTransport()->flush();
  oprot->getTransport()->writeEnd();
}

void HbaseProcessor::process_disableTable(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot)
{
  Hbase_disableTable_args args;
  args.read(iprot);
  iprot->readMessageEnd();
  iprot->getTransport()->readEnd();

  Hbase_disableTable_result result;
  try {
    iface_->disableTable(args.tableName);
  } catch (IOError &io) {
    result.io = io;
    result.__isset.io = true;
  } catch (const std::exception& e) {
    facebook::thrift::TApplicationException x(e.what());
    oprot->writeMessageBegin("disableTable", facebook::thrift::protocol::T_EXCEPTION, seqid);
    x.write(oprot);
    oprot->writeMessageEnd();
    oprot->getTransport()->flush();
    oprot->getTransport()->writeEnd();
    return;
  }

  oprot->writeMessageBegin("disableTable", facebook::thrift::protocol::T_REPLY, seqid);
  result.write(oprot);
  oprot->writeMessageEnd();
  oprot->getTransport()->flush();
  oprot->getTransport()->writeEnd();
}

void HbaseProcessor::process_isTableEnabled(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot)
{
  Hbase_isTableEnabled_args args;
  args.read(iprot);
  iprot->readMessageEnd();
  iprot->getTransport()->readEnd();

  Hbase_isTableEnabled_result result;
  try {
    result.success = iface_->isTableEnabled(args.tableName);
    result.__isset.success = true;
  } catch (IOError &io) {
    result.io = io;
    result.__isset.io = true;
  } catch (const std::exception& e) {
    facebook::thrift::TApplicationException x(e.what());
    oprot->writeMessageBegin("isTableEnabled", facebook::thrift::protocol::T_EXCEPTION, seqid);
    x.write(oprot);
    oprot->writeMessageEnd();
    oprot->getTransport()->flush();
    oprot->getTransport()->writeEnd();
    return;
  }

  oprot->writeMessageBegin("isTableEnabled", facebook::thrift::protocol::T_REPLY, seqid);
  result.write(oprot);
  oprot->writeMessageEnd();
  oprot->getTransport()->flush();
  oprot->getTransport()->writeEnd();
}

void HbaseProcessor::process_getTableNames(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot)
{
  Hbase_getTableNames_args args;
  args.read(iprot);
  iprot->readMessageEnd();
  iprot->getTransport()->readEnd();

  Hbase_getTableNames_result result;
  try {
    iface_->getTableNames(result.success);
    result.__isset.success = true;
  } catch (IOError &io) {
    result.io = io;
    result.__isset.io = true;
  } catch (const std::exception& e) {
    facebook::thrift::TApplicationException x(e.what());
    oprot->writeMessageBegin("getTableNames", facebook::thrift::protocol::T_EXCEPTION, seqid);
    x.write(oprot);
    oprot->writeMessageEnd();
    oprot->getTransport()->flush();
    oprot->getTransport()->writeEnd();
    return;
  }

  oprot->writeMessageBegin("getTableNames", facebook::thrift::protocol::T_REPLY, seqid);
  result.write(oprot);
  oprot->writeMessageEnd();
  oprot->getTransport()->flush();
  oprot->getTransport()->writeEnd();
}

void HbaseProcessor::process_getColumnDescriptors(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot)
{
  Hbase_getColumnDescriptors_args args;
  args.read(iprot);
  iprot->readMessageEnd();
  iprot->getTransport()->readEnd();

  Hbase_getColumnDescriptors_result result;
  try {
    iface_->getColumnDescriptors(result.success, args.tableName);
    result.__isset.success = true;
  } catch (IOError &io) {
    result.io = io;
    result.__isset.io = true;
  } catch (const std::exception& e) {
    facebook::thrift::TApplicationException x(e.what());
    oprot->writeMessageBegin("getColumnDescriptors", facebook::thrift::protocol::T_EXCEPTION, seqid);
    x.write(oprot);
    oprot->writeMessageEnd();
    oprot->getTransport()->flush();
    oprot->getTransport()->writeEnd();
    return;
  }

  oprot->writeMessageBegin("getColumnDescriptors", facebook::thrift::protocol::T_REPLY, seqid);
  result.write(oprot);
  oprot->writeMessageEnd();
  oprot->getTransport()->flush();
  oprot->getTransport()->writeEnd();
}

void HbaseProcessor::process_getTableRegions(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot)
{
  Hbase_getTableRegions_args args;
  args.read(iprot);
  iprot->readMessageEnd();
  iprot->getTransport()->readEnd();

  Hbase_getTableRegions_result result;
  try {
    iface_->getTableRegions(result.success, args.tableName);
    result.__isset.success = true;
  } catch (IOError &io) {
    result.io = io;
    result.__isset.io = true;
  } catch (const std::exception& e) {
    facebook::thrift::TApplicationException x(e.what());
    oprot->writeMessageBegin("getTableRegions", facebook::thrift::protocol::T_EXCEPTION, seqid);
    x.write(oprot);
    oprot->writeMessageEnd();
    oprot->getTransport()->flush();
    oprot->getTransport()->writeEnd();
    return;
  }

  oprot->writeMessageBegin("getTableRegions", facebook::thrift::protocol::T_REPLY, seqid);
  result.write(oprot);
  oprot->writeMessageEnd();
  oprot->getTransport()->flush();
  oprot->getTransport()->writeEnd();
}

void HbaseProcessor::process_createTable(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot)
{
  Hbase_createTable_args args;
  args.read(iprot);
  iprot->readMessageEnd();
  iprot->getTransport()->readEnd();

  Hbase_createTable_result result;
  try {
    iface_->createTable(args.tableName, args.columnFamilies);
  } catch (IOError &io) {
    result.io = io;
    result.__isset.io = true;
  } catch (IllegalArgument &ia) {
    result.ia = ia;
    result.__isset.ia = true;
  } catch (AlreadyExists &exist) {
    result.exist = exist;
    result.__isset.exist = true;
  } catch (const std::exception& e) {
    facebook::thrift::TApplicationException x(e.what());
    oprot->writeMessageBegin("createTable", facebook::thrift::protocol::T_EXCEPTION, seqid);
    x.write(oprot);
    oprot->writeMessageEnd();
    oprot->getTransport()->flush();
    oprot->getTransport()->writeEnd();
    return;
  }

  oprot->writeMessageBegin("createTable", facebook::thrift::protocol::T_REPLY, seqid);
  result.write(oprot);
  oprot->writeMessageEnd();
  oprot->getTransport()->flush();
  oprot->getTransport()->writeEnd();
}

void HbaseProcessor::process_deleteTable(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot)
{
  Hbase_deleteTable_args args;
  args.read(iprot);
  iprot->readMessageEnd();
  iprot->getTransport()->readEnd();

  Hbase_deleteTable_result result;
  try {
    iface_->deleteTable(args.tableName);
  } catch (IOError &io) {
    result.io = io;
    result.__isset.io = true;
  } catch (NotFound &nf) {
    result.nf = nf;
    result.__isset.nf = true;
  } catch (const std::exception& e) {
    facebook::thrift::TApplicationException x(e.what());
    oprot->writeMessageBegin("deleteTable", facebook::thrift::protocol::T_EXCEPTION, seqid);
    x.write(oprot);
    oprot->writeMessageEnd();
    oprot->getTransport()->flush();
    oprot->getTransport()->writeEnd();
    return;
  }

  oprot->writeMessageBegin("deleteTable", facebook::thrift::protocol::T_REPLY, seqid);
  result.write(oprot);
  oprot->writeMessageEnd();
  oprot->getTransport()->flush();
  oprot->getTransport()->writeEnd();
}

void HbaseProcessor::process_get(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot)
{
  Hbase_get_args args;
  args.read(iprot);
  iprot->readMessageEnd();
  iprot->getTransport()->readEnd();

  Hbase_get_result result;
  try {
    iface_->get(result.success, args.tableName, args.row, args.column);
    result.__isset.success = true;
  } catch (IOError &io) {
    result.io = io;
    result.__isset.io = true;
  } catch (NotFound &nf) {
    result.nf = nf;
    result.__isset.nf = true;
  } catch (const std::exception& e) {
    facebook::thrift::TApplicationException x(e.what());
    oprot->writeMessageBegin("get", facebook::thrift::protocol::T_EXCEPTION, seqid);
    x.write(oprot);
    oprot->writeMessageEnd();
    oprot->getTransport()->flush();
    oprot->getTransport()->writeEnd();
    return;
  }

  oprot->writeMessageBegin("get", facebook::thrift::protocol::T_REPLY, seqid);
  result.write(oprot);
  oprot->writeMessageEnd();
  oprot->getTransport()->flush();
  oprot->getTransport()->writeEnd();
}

void HbaseProcessor::process_getVer(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot)
{
  Hbase_getVer_args args;
  args.read(iprot);
  iprot->readMessageEnd();
  iprot->getTransport()->readEnd();

  Hbase_getVer_result result;
  try {
    iface_->getVer(result.success, args.tableName, args.row, args.column, args.numVersions);
    result.__isset.success = true;
  } catch (IOError &io) {
    result.io = io;
    result.__isset.io = true;
  } catch (NotFound &nf) {
    result.nf = nf;
    result.__isset.nf = true;
  } catch (const std::exception& e) {
    facebook::thrift::TApplicationException x(e.what());
    oprot->writeMessageBegin("getVer", facebook::thrift::protocol::T_EXCEPTION, seqid);
    x.write(oprot);
    oprot->writeMessageEnd();
    oprot->getTransport()->flush();
    oprot->getTransport()->writeEnd();
    return;
  }

  oprot->writeMessageBegin("getVer", facebook::thrift::protocol::T_REPLY, seqid);
  result.write(oprot);
  oprot->writeMessageEnd();
  oprot->getTransport()->flush();
  oprot->getTransport()->writeEnd();
}

void HbaseProcessor::process_getVerTs(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot)
{
  Hbase_getVerTs_args args;
  args.read(iprot);
  iprot->readMessageEnd();
  iprot->getTransport()->readEnd();

  Hbase_getVerTs_result result;
  try {
    iface_->getVerTs(result.success, args.tableName, args.row, args.column, args.timestamp, args.numVersions);
    result.__isset.success = true;
  } catch (IOError &io) {
    result.io = io;
    result.__isset.io = true;
  } catch (NotFound &nf) {
    result.nf = nf;
    result.__isset.nf = true;
  } catch (const std::exception& e) {
    facebook::thrift::TApplicationException x(e.what());
    oprot->writeMessageBegin("getVerTs", facebook::thrift::protocol::T_EXCEPTION, seqid);
    x.write(oprot);
    oprot->writeMessageEnd();
    oprot->getTransport()->flush();
    oprot->getTransport()->writeEnd();
    return;
  }

  oprot->writeMessageBegin("getVerTs", facebook::thrift::protocol::T_REPLY, seqid);
  result.write(oprot);
  oprot->writeMessageEnd();
  oprot->getTransport()->flush();
  oprot->getTransport()->writeEnd();
}

void HbaseProcessor::process_getRow(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot)
{
  Hbase_getRow_args args;
  args.read(iprot);
  iprot->readMessageEnd();
  iprot->getTransport()->readEnd();

  Hbase_getRow_result result;
  try {
    iface_->getRow(result.success, args.tableName, args.row);
    result.__isset.success = true;
  } catch (IOError &io) {
    result.io = io;
    result.__isset.io = true;
  } catch (const std::exception& e) {
    facebook::thrift::TApplicationException x(e.what());
    oprot->writeMessageBegin("getRow", facebook::thrift::protocol::T_EXCEPTION, seqid);
    x.write(oprot);
    oprot->writeMessageEnd();
    oprot->getTransport()->flush();
    oprot->getTransport()->writeEnd();
    return;
  }

  oprot->writeMessageBegin("getRow", facebook::thrift::protocol::T_REPLY, seqid);
  result.write(oprot);
  oprot->writeMessageEnd();
  oprot->getTransport()->flush();
  oprot->getTransport()->writeEnd();
}

void HbaseProcessor::process_getRowTs(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot)
{
  Hbase_getRowTs_args args;
  args.read(iprot);
  iprot->readMessageEnd();
  iprot->getTransport()->readEnd();

  Hbase_getRowTs_result result;
  try {
    iface_->getRowTs(result.success, args.tableName, args.row, args.timestamp);
    result.__isset.success = true;
  } catch (IOError &io) {
    result.io = io;
    result.__isset.io = true;
  } catch (const std::exception& e) {
    facebook::thrift::TApplicationException x(e.what());
    oprot->writeMessageBegin("getRowTs", facebook::thrift::protocol::T_EXCEPTION, seqid);
    x.write(oprot);
    oprot->writeMessageEnd();
    oprot->getTransport()->flush();
    oprot->getTransport()->writeEnd();
    return;
  }

  oprot->writeMessageBegin("getRowTs", facebook::thrift::protocol::T_REPLY, seqid);
  result.write(oprot);
  oprot->writeMessageEnd();
  oprot->getTransport()->flush();
  oprot->getTransport()->writeEnd();
}

void HbaseProcessor::process_mutateRow(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot)
{
  Hbase_mutateRow_args args;
  args.read(iprot);
  iprot->readMessageEnd();
  iprot->getTransport()->readEnd();

  Hbase_mutateRow_result result;
  try {
    iface_->mutateRow(args.tableName, args.row, args.mutations);
  } catch (IOError &io) {
    result.io = io;
    result.__isset.io = true;
  } catch (IllegalArgument &ia) {
    result.ia = ia;
    result.__isset.ia = true;
  } catch (const std::exception& e) {
    facebook::thrift::TApplicationException x(e.what());
    oprot->writeMessageBegin("mutateRow", facebook::thrift::protocol::T_EXCEPTION, seqid);
    x.write(oprot);
    oprot->writeMessageEnd();
    oprot->getTransport()->flush();
    oprot->getTransport()->writeEnd();
    return;
  }

  oprot->writeMessageBegin("mutateRow", facebook::thrift::protocol::T_REPLY, seqid);
  result.write(oprot);
  oprot->writeMessageEnd();
  oprot->getTransport()->flush();
  oprot->getTransport()->writeEnd();
}

void HbaseProcessor::process_mutateRowTs(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot)
{
  Hbase_mutateRowTs_args args;
  args.read(iprot);
  iprot->readMessageEnd();
  iprot->getTransport()->readEnd();

  Hbase_mutateRowTs_result result;
  try {
    iface_->mutateRowTs(args.tableName, args.row, args.mutations, args.timestamp);
  } catch (IOError &io) {
    result.io = io;
    result.__isset.io = true;
  } catch (IllegalArgument &ia) {
    result.ia = ia;
    result.__isset.ia = true;
  } catch (const std::exception& e) {
    facebook::thrift::TApplicationException x(e.what());
    oprot->writeMessageBegin("mutateRowTs", facebook::thrift::protocol::T_EXCEPTION, seqid);
    x.write(oprot);
    oprot->writeMessageEnd();
    oprot->getTransport()->flush();
    oprot->getTransport()->writeEnd();
    return;
  }

  oprot->writeMessageBegin("mutateRowTs", facebook::thrift::protocol::T_REPLY, seqid);
  result.write(oprot);
  oprot->writeMessageEnd();
  oprot->getTransport()->flush();
  oprot->getTransport()->writeEnd();
}

void HbaseProcessor::process_mutateRows(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot)
{
  Hbase_mutateRows_args args;
  args.read(iprot);
  iprot->readMessageEnd();
  iprot->getTransport()->readEnd();

  Hbase_mutateRows_result result;
  try {
    iface_->mutateRows(args.tableName, args.rowBatches);
  } catch (IOError &io) {
    result.io = io;
    result.__isset.io = true;
  } catch (IllegalArgument &ia) {
    result.ia = ia;
    result.__isset.ia = true;
  } catch (const std::exception& e) {
    facebook::thrift::TApplicationException x(e.what());
    oprot->writeMessageBegin("mutateRows", facebook::thrift::protocol::T_EXCEPTION, seqid);
    x.write(oprot);
    oprot->writeMessageEnd();
    oprot->getTransport()->flush();
    oprot->getTransport()->writeEnd();
    return;
  }

  oprot->writeMessageBegin("mutateRows", facebook::thrift::protocol::T_REPLY, seqid);
  result.write(oprot);
  oprot->writeMessageEnd();
  oprot->getTransport()->flush();
  oprot->getTransport()->writeEnd();
}

void HbaseProcessor::process_mutateRowsTs(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot)
{
  Hbase_mutateRowsTs_args args;
  args.read(iprot);
  iprot->readMessageEnd();
  iprot->getTransport()->readEnd();

  Hbase_mutateRowsTs_result result;
  try {
    iface_->mutateRowsTs(args.tableName, args.rowBatches, args.timestamp);
  } catch (IOError &io) {
    result.io = io;
    result.__isset.io = true;
  } catch (IllegalArgument &ia) {
    result.ia = ia;
    result.__isset.ia = true;
  } catch (const std::exception& e) {
    facebook::thrift::TApplicationException x(e.what());
    oprot->writeMessageBegin("mutateRowsTs", facebook::thrift::protocol::T_EXCEPTION, seqid);
    x.write(oprot);
    oprot->writeMessageEnd();
    oprot->getTransport()->flush();
    oprot->getTransport()->writeEnd();
    return;
  }

  oprot->writeMessageBegin("mutateRowsTs", facebook::thrift::protocol::T_REPLY, seqid);
  result.write(oprot);
  oprot->writeMessageEnd();
  oprot->getTransport()->flush();
  oprot->getTransport()->writeEnd();
}

void HbaseProcessor::process_deleteAll(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot)
{
  Hbase_deleteAll_args args;
  args.read(iprot);
  iprot->readMessageEnd();
  iprot->getTransport()->readEnd();

  Hbase_deleteAll_result result;
  try {
    iface_->deleteAll(args.tableName, args.row, args.column);
  } catch (IOError &io) {
    result.io = io;
    result.__isset.io = true;
  } catch (const std::exception& e) {
    facebook::thrift::TApplicationException x(e.what());
    oprot->writeMessageBegin("deleteAll", facebook::thrift::protocol::T_EXCEPTION, seqid);
    x.write(oprot);
    oprot->writeMessageEnd();
    oprot->getTransport()->flush();
    oprot->getTransport()->writeEnd();
    return;
  }

  oprot->writeMessageBegin("deleteAll", facebook::thrift::protocol::T_REPLY, seqid);
  result.write(oprot);
  oprot->writeMessageEnd();
  oprot->getTransport()->flush();
  oprot->getTransport()->writeEnd();
}

void HbaseProcessor::process_deleteAllTs(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot)
{
  Hbase_deleteAllTs_args args;
  args.read(iprot);
  iprot->readMessageEnd();
  iprot->getTransport()->readEnd();

  Hbase_deleteAllTs_result result;
  try {
    iface_->deleteAllTs(args.tableName, args.row, args.column, args.timestamp);
  } catch (IOError &io) {
    result.io = io;
    result.__isset.io = true;
  } catch (const std::exception& e) {
    facebook::thrift::TApplicationException x(e.what());
    oprot->writeMessageBegin("deleteAllTs", facebook::thrift::protocol::T_EXCEPTION, seqid);
    x.write(oprot);
    oprot->writeMessageEnd();
    oprot->getTransport()->flush();
    oprot->getTransport()->writeEnd();
    return;
  }

  oprot->writeMessageBegin("deleteAllTs", facebook::thrift::protocol::T_REPLY, seqid);
  result.write(oprot);
  oprot->writeMessageEnd();
  oprot->getTransport()->flush();
  oprot->getTransport()->writeEnd();
}

void HbaseProcessor::process_deleteAllRow(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot)
{
  Hbase_deleteAllRow_args args;
  args.read(iprot);
  iprot->readMessageEnd();
  iprot->getTransport()->readEnd();

  Hbase_deleteAllRow_result result;
  try {
    iface_->deleteAllRow(args.tableName, args.row);
  } catch (IOError &io) {
    result.io = io;
    result.__isset.io = true;
  } catch (const std::exception& e) {
    facebook::thrift::TApplicationException x(e.what());
    oprot->writeMessageBegin("deleteAllRow", facebook::thrift::protocol::T_EXCEPTION, seqid);
    x.write(oprot);
    oprot->writeMessageEnd();
    oprot->getTransport()->flush();
    oprot->getTransport()->writeEnd();
    return;
  }

  oprot->writeMessageBegin("deleteAllRow", facebook::thrift::protocol::T_REPLY, seqid);
  result.write(oprot);
  oprot->writeMessageEnd();
  oprot->getTransport()->flush();
  oprot->getTransport()->writeEnd();
}

void HbaseProcessor::process_deleteAllRowTs(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot)
{
  Hbase_deleteAllRowTs_args args;
  args.read(iprot);
  iprot->readMessageEnd();
  iprot->getTransport()->readEnd();

  Hbase_deleteAllRowTs_result result;
  try {
    iface_->deleteAllRowTs(args.tableName, args.row, args.timestamp);
  } catch (IOError &io) {
    result.io = io;
    result.__isset.io = true;
  } catch (const std::exception& e) {
    facebook::thrift::TApplicationException x(e.what());
    oprot->writeMessageBegin("deleteAllRowTs", facebook::thrift::protocol::T_EXCEPTION, seqid);
    x.write(oprot);
    oprot->writeMessageEnd();
    oprot->getTransport()->flush();
    oprot->getTransport()->writeEnd();
    return;
  }

  oprot->writeMessageBegin("deleteAllRowTs", facebook::thrift::protocol::T_REPLY, seqid);
  result.write(oprot);
  oprot->writeMessageEnd();
  oprot->getTransport()->flush();
  oprot->getTransport()->writeEnd();
}

void HbaseProcessor::process_scannerOpen(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot)
{
  Hbase_scannerOpen_args args;
  args.read(iprot);
  iprot->readMessageEnd();
  iprot->getTransport()->readEnd();

  Hbase_scannerOpen_result result;
  try {
    result.success = iface_->scannerOpen(args.tableName, args.startRow, args.columns);
    result.__isset.success = true;
  } catch (IOError &io) {
    result.io = io;
    result.__isset.io = true;
  } catch (const std::exception& e) {
    facebook::thrift::TApplicationException x(e.what());
    oprot->writeMessageBegin("scannerOpen", facebook::thrift::protocol::T_EXCEPTION, seqid);
    x.write(oprot);
    oprot->writeMessageEnd();
    oprot->getTransport()->flush();
    oprot->getTransport()->writeEnd();
    return;
  }

  oprot->writeMessageBegin("scannerOpen", facebook::thrift::protocol::T_REPLY, seqid);
  result.write(oprot);
  oprot->writeMessageEnd();
  oprot->getTransport()->flush();
  oprot->getTransport()->writeEnd();
}

void HbaseProcessor::process_scannerOpenWithStop(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot)
{
  Hbase_scannerOpenWithStop_args args;
  args.read(iprot);
  iprot->readMessageEnd();
  iprot->getTransport()->readEnd();

  Hbase_scannerOpenWithStop_result result;
  try {
    result.success = iface_->scannerOpenWithStop(args.tableName, args.startRow, args.stopRow, args.columns);
    result.__isset.success = true;
  } catch (IOError &io) {
    result.io = io;
    result.__isset.io = true;
  } catch (const std::exception& e) {
    facebook::thrift::TApplicationException x(e.what());
    oprot->writeMessageBegin("scannerOpenWithStop", facebook::thrift::protocol::T_EXCEPTION, seqid);
    x.write(oprot);
    oprot->writeMessageEnd();
    oprot->getTransport()->flush();
    oprot->getTransport()->writeEnd();
    return;
  }

  oprot->writeMessageBegin("scannerOpenWithStop", facebook::thrift::protocol::T_REPLY, seqid);
  result.write(oprot);
  oprot->writeMessageEnd();
  oprot->getTransport()->flush();
  oprot->getTransport()->writeEnd();
}

void HbaseProcessor::process_scannerOpenTs(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot)
{
  Hbase_scannerOpenTs_args args;
  args.read(iprot);
  iprot->readMessageEnd();
  iprot->getTransport()->readEnd();

  Hbase_scannerOpenTs_result result;
  try {
    result.success = iface_->scannerOpenTs(args.tableName, args.startRow, args.columns, args.timestamp);
    result.__isset.success = true;
  } catch (IOError &io) {
    result.io = io;
    result.__isset.io = true;
  } catch (const std::exception& e) {
    facebook::thrift::TApplicationException x(e.what());
    oprot->writeMessageBegin("scannerOpenTs", facebook::thrift::protocol::T_EXCEPTION, seqid);
    x.write(oprot);
    oprot->writeMessageEnd();
    oprot->getTransport()->flush();
    oprot->getTransport()->writeEnd();
    return;
  }

  oprot->writeMessageBegin("scannerOpenTs", facebook::thrift::protocol::T_REPLY, seqid);
  result.write(oprot);
  oprot->writeMessageEnd();
  oprot->getTransport()->flush();
  oprot->getTransport()->writeEnd();
}

void HbaseProcessor::process_scannerOpenWithStopTs(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot)
{
  Hbase_scannerOpenWithStopTs_args args;
  args.read(iprot);
  iprot->readMessageEnd();
  iprot->getTransport()->readEnd();

  Hbase_scannerOpenWithStopTs_result result;
  try {
    result.success = iface_->scannerOpenWithStopTs(args.tableName, args.startRow, args.stopRow, args.columns, args.timestamp);
    result.__isset.success = true;
  } catch (IOError &io) {
    result.io = io;
    result.__isset.io = true;
  } catch (const std::exception& e) {
    facebook::thrift::TApplicationException x(e.what());
    oprot->writeMessageBegin("scannerOpenWithStopTs", facebook::thrift::protocol::T_EXCEPTION, seqid);
    x.write(oprot);
    oprot->writeMessageEnd();
    oprot->getTransport()->flush();
    oprot->getTransport()->writeEnd();
    return;
  }

  oprot->writeMessageBegin("scannerOpenWithStopTs", facebook::thrift::protocol::T_REPLY, seqid);
  result.write(oprot);
  oprot->writeMessageEnd();
  oprot->getTransport()->flush();
  oprot->getTransport()->writeEnd();
}

void HbaseProcessor::process_scannerGet(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot)
{
  Hbase_scannerGet_args args;
  args.read(iprot);
  iprot->readMessageEnd();
  iprot->getTransport()->readEnd();

  Hbase_scannerGet_result result;
  try {
    iface_->scannerGet(result.success, args.id);
    result.__isset.success = true;
  } catch (IOError &io) {
    result.io = io;
    result.__isset.io = true;
  } catch (IllegalArgument &ia) {
    result.ia = ia;
    result.__isset.ia = true;
  } catch (NotFound &nf) {
    result.nf = nf;
    result.__isset.nf = true;
  } catch (const std::exception& e) {
    facebook::thrift::TApplicationException x(e.what());
    oprot->writeMessageBegin("scannerGet", facebook::thrift::protocol::T_EXCEPTION, seqid);
    x.write(oprot);
    oprot->writeMessageEnd();
    oprot->getTransport()->flush();
    oprot->getTransport()->writeEnd();
    return;
  }

  oprot->writeMessageBegin("scannerGet", facebook::thrift::protocol::T_REPLY, seqid);
  result.write(oprot);
  oprot->writeMessageEnd();
  oprot->getTransport()->flush();
  oprot->getTransport()->writeEnd();
}

void HbaseProcessor::process_scannerClose(int32_t seqid, facebook::thrift::protocol::TProtocol* iprot, facebook::thrift::protocol::TProtocol* oprot)
{
  Hbase_scannerClose_args args;
  args.read(iprot);
  iprot->readMessageEnd();
  iprot->getTransport()->readEnd();

  Hbase_scannerClose_result result;
  try {
    iface_->scannerClose(args.id);
  } catch (IOError &io) {
    result.io = io;
    result.__isset.io = true;
  } catch (IllegalArgument &ia) {
    result.ia = ia;
    result.__isset.ia = true;
  } catch (const std::exception& e) {
    facebook::thrift::TApplicationException x(e.what());
    oprot->writeMessageBegin("scannerClose", facebook::thrift::protocol::T_EXCEPTION, seqid);
    x.write(oprot);
    oprot->writeMessageEnd();
    oprot->getTransport()->flush();
    oprot->getTransport()->writeEnd();
    return;
  }

  oprot->writeMessageBegin("scannerClose", facebook::thrift::protocol::T_REPLY, seqid);
  result.write(oprot);
  oprot->writeMessageEnd();
  oprot->getTransport()->flush();
  oprot->getTransport()->writeEnd();
}

}}}} // namespace